agent-apprenticeship 0.1.6 → 0.1.8

package/src/agent_apprenticeship_trace/cli.py

@@ -24,12 +24,21 @@ from .bundle_exporter import create_contribution_bundle
 from .release_exporter import create_release as create_release_impl
 from .validation import validate_release as validate_release_impl, format_counters
 from .config import (
+    APPRENTICESHIP_MODES,
     DATA_SHARING_LEVELS,
+    DEFAULT_ECOSYSTEM_STORAGE_BACKEND,
     DEFAULT_PUBLIC_ECOSYSTEM_REPO,
+    DEFAULT_R2_BUCKET,
+    DEFAULT_R2_CONTRIBUTION_PREFIX,
+    DEFAULT_R2_INDEX_PREFIX,
+    DEFAULT_R2_SEED_PREFIX,
     ECOSYSTEM_AUTO_SHARE_MODES,
     EVALUATION_MODES,
     MENTOR_MODES,
     SENSITIVE_INFO_MASKING_LEVELS,
+    TRAINING_CONTRIBUTION_MODES,
+    apprenticeship_mode_display,
+    apprenticeship_mode_to_mentor_mode,
     ecosystem_auto_share_display,
     get_settings,
     init_settings,
@@ -38,14 +47,33 @@ from .config import (
     apprentice_agent_readiness_status,
     mentor_model_provider_readiness,
     mentor_mode_display,
+    mentor_mode_to_evaluation_mode,
+    normalize_apprenticeship_mode,
     normalize_mentor_mode,
     normalize_ecosystem_auto_share,
+    normalize_ecosystem_storage,
     normalize_sensitive_info_masking,
+    normalize_training_contribution_mode,
+    training_contribution_mode_display,
     debug_settings,
     public_settings,
     public_settings_text,
     update_settings,
 )
+from .ecosystem_r2 import (
+    append_successful_share,
+    download_r2_package,
+    ecosystem_item_from_bundle,
+    fetch_r2_index,
+    fetch_r2_item,
+    get_or_create_ecosystem_identity,
+    r2_api_url,
+    r2_status,
+    shared_history,
+    storage_ref_for_item,
+    upload_contribution_to_worker,
+    write_storage_ref,
+)
 from .openai_structured import run_llm_smoke, format_smoke_counters
 from .env import contains_secret, redact_secrets
 from .public_sanitizer import sanitize_public_obj, sanitize_public_text
@@ -56,6 +84,9 @@ from .learning import (
     active_packs,
     compare_replay,
     compile_experience_pack,
+    install_runtime_training_from_bundle,
+    installed_skill_run_refs,
+    list_installed_skills,
     list_packs,
     load_pack,
     pack_run_refs,
@@ -64,7 +95,10 @@ from .learning import (
     resolve_learning_source,
     resolve_packs_for_run,
     search_learning_sources,
+    select_runtime_training_for_run,
+    set_installed_skill_enabled,
     slugify,
+    uninstall_installed_skill,
     update_pack_status,
     write_before_after_result,
 )
@@ -73,11 +107,13 @@ from .progress import append_progress_event, format_progress_event, format_run_s
 from .recipes import MODEL_PROVIDER_RECIPES, WORKER_AGENT_RECIPES
 app=typer.Typer(add_completion=False)
 configure_app=typer.Typer(add_completion=False, help='Configure Apprentice Agents and Mentor Model Providers.')
-ecosystem_app=typer.Typer(add_completion=False, help='Explore and contribute Agent Apprenticeship ecosystem bundles.')
-bundle_app=typer.Typer(add_completion=False, help='Inspect local Contribution Bundles.')
+ecosystem_app=typer.Typer(add_completion=False, help='Explore and share Agent Apprenticeship Experience Compilations.')
+ecosystem_shared_app=typer.Typer(add_completion=False, help='Inspect local shared Experience Compilation history.')
+bundle_app=typer.Typer(add_completion=False, help='Inspect local Experience Compilations.')
 learn_app=typer.Typer(add_completion=False, help='Create and apply reversible Experience Packs from ecosystem experience.')
 app.add_typer(configure_app, name='configure')
 app.add_typer(ecosystem_app, name='ecosystem')
+ecosystem_app.add_typer(ecosystem_shared_app, name='shared')
 app.add_typer(bundle_app, name='bundle')
 app.add_typer(learn_app, name='learn')
 
@@ -102,9 +138,9 @@ def _split_asset_prompt(text: str) -> list[Path]:
 def _print_bundle_ready(bundle: Path | None) -> None:
     if not bundle:
         return
-    typer.echo(f'Contribution Bundle path: {bundle}')
+    typer.echo(f'Experience Compilation path: {bundle}')
     typer.echo(f'Contribute to public ecosystem: apprentice ecosystem contribute {bundle}')
-    typer.echo(f'Public ecosystem: {_ecosystem_repo_url()}')
+    typer.echo('Public ecosystem: Forsy ecosystem')
     typer.echo(f'View files: open {bundle}')
 
 
@@ -113,7 +149,7 @@ def _print_public_ecosystem_contribution_help(bundle: str | Path) -> None:
     typer.echo(f'apprentice ecosystem contribute {bundle}')
     typer.echo('')
     typer.echo('Public ecosystem:')
-    typer.echo(_ecosystem_repo_url())
+    typer.echo('Forsy ecosystem')
 
 
 def _print_first_run_banner() -> None:
@@ -156,15 +192,14 @@ def _print_task_result(
         typer.echo(f'{label}:')
         typer.echo(str(artifacts))
     if bundle:
-        typer.echo('Contribution Bundle:')
+        typer.echo('Experience Compilation:')
         typer.echo(str(bundle))
         if include_contribution_help:
             typer.echo('')
-            mode = get_settings().ecosystem_auto_share
-            if mode == "manual":
+            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)
-            else:
-                typer.echo(f'Ecosystem Auto-Share: {ecosystem_auto_share_display(mode)}')
             typer.echo('')
             typer.echo('View files:')
             typer.echo(f'open {bundle}')
@@ -184,15 +219,14 @@ def _print_session_finished(status: dict, *, include_contribution_help: bool=Tru
         typer.echo("Artifacts:")
         typer.echo(str(status.get('artifacts_path')))
     if status.get('contribution_bundle_path'):
-        typer.echo("Contribution Bundle:")
+        typer.echo("Experience Compilation:")
         typer.echo(str(status.get('contribution_bundle_path')))
         if include_contribution_help:
             typer.echo('')
-            mode = get_settings().ecosystem_auto_share
-            if mode == "manual":
+            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'))
-            else:
-                typer.echo(f'Ecosystem Auto-Share: {ecosystem_auto_share_display(mode)}')
             typer.echo('')
             typer.echo('View files:')
             typer.echo(f"open {status.get('contribution_bundle_path')}")
@@ -327,6 +361,7 @@ def _configure_detected_model_provider(row: dict) -> None:
 
 def _first_run_setup(*, interactive: bool, defaults: bool=False) -> None:
     detected_agents = _detect_apprentice_agents()
+    detected_providers = _detect_model_provider_keys()
     typer.echo("")
     if detected_agents:
         typer.echo("Detected Apprentice Agents:")
@@ -351,7 +386,6 @@ def _first_run_setup(*, interactive: bool, defaults: bool=False) -> None:
         typer.echo("Or choose Custom to provide a command template.")
         typer.echo("Then rerun: apprentice init --setup")
 
-    detected_providers = _detect_model_provider_keys()
     typer.echo("")
     if detected_providers:
         typer.echo("Detected Mentor Model Provider keys:")
@@ -370,6 +404,37 @@ def _first_run_setup(*, interactive: bool, defaults: bool=False) -> None:
         typer.echo("No Mentor Model Provider API key was detected.")
         _print_key_storage_guidance()
 
+    typer.echo("")
+    default_mode = "autonomous" if detected_providers else "expert_led"
+    if defaults:
+        mode = default_mode
+        update_settings(apprenticeship_mode=mode, training_contribution_mode="public_ecosystem")
+        typer.echo(f"Configured Apprenticeship Mode: {apprenticeship_mode_display(mode)}")
+        typer.echo("Configured Agent Training Contribution Mode: Public Ecosystem")
+    elif interactive and sys.stdin.isatty():
+        typer.echo("Choose Apprenticeship Mode:")
+        typer.echo("1. Autonomous Apprenticeship")
+        typer.echo("2. Expert-Led Apprenticeship")
+        typer.echo("3. Organization Custom")
+        mode_choice = typer.prompt("Default", default=get_settings().apprenticeship_mode or default_mode).strip().lower()
+        mode = {"1": "autonomous", "2": "expert_led", "3": "org_custom"}.get(mode_choice, mode_choice)
+        mode = normalize_apprenticeship_mode(mode)
+        if mode == "org_custom":
+            typer.echo("Organization Custom is available through private setup. Visit https://agentapprenticeship.org/custom")
+        typer.echo("")
+        typer.echo("Choose Agent Training Contribution Mode:")
+        typer.echo("1. Public Ecosystem")
+        typer.echo("2. Private Internal Only")
+        contribution_choice = typer.prompt("Default", default=get_settings().training_contribution_mode).strip().lower()
+        contribution = {"1": "public_ecosystem", "2": "private_internal_only"}.get(contribution_choice, contribution_choice)
+        update_settings(apprenticeship_mode=mode, training_contribution_mode=contribution)
+        typer.echo(f"Configured Apprenticeship Mode: {apprenticeship_mode_display(mode)}")
+        typer.echo(f"Configured Agent Training Contribution Mode: {training_contribution_mode_display(contribution)}")
+    elif interactive:
+        update_settings(apprenticeship_mode=default_mode, training_contribution_mode="public_ecosystem")
+        typer.echo(f"Configured Apprenticeship Mode: {apprenticeship_mode_display(default_mode)}")
+        typer.echo("Configured Agent Training Contribution Mode: Public Ecosystem")
+
 
 def _progress_callback(quiet: bool=False, verbose: bool=False, json_progress: bool=False):
     if quiet:
@@ -384,7 +449,7 @@ def _progress_callback(quiet: bool=False, verbose: bool=False, json_progress: bo
             typer.echo('')
             typer.echo(f'Run: {status.get("run_id")}')
             typer.echo(f'Apprentice Agent: {status.get("apprentice_agent") or status.get("worker_agent")}')
-            typer.echo(f'Mentor Mode: {mentor_mode_display(status.get("mentor_mode"))}')
+            typer.echo(f'Apprenticeship Mode: {apprenticeship_mode_display(status.get("apprenticeship_mode") or status.get("mentor_mode"))}')
             typer.echo(f'Maximum Improvement Loops: {status.get("maximum_improvement_loops")}')
             typer.echo(f'Task workspace: {status.get("task_workspace_path")}')
             typer.echo(f'Artifacts: {status.get("artifacts_path")}')
@@ -399,6 +464,16 @@ def _progress_callback(quiet: bool=False, verbose: bool=False, json_progress: bo
         if event_type in {'followup_completed'}:
             _print_task_result(status, followup=True, record_only=bool((event.get('metadata_json') or {}).get('record_only')))
             return
+        if event_type == 'task_outputs_ready':
+            typer.echo('')
+            task_status = event.get('task_status') or status.get('task_status')
+            typer.echo('Task completed.' if task_status == 'completed' else 'Task outputs are available.')
+            if event.get('artifacts_path'):
+                typer.echo(f"Artifacts are available at: {event.get('artifacts_path')}")
+            return
+        if event_type in {'tdo_started','tdo_round_generated','tdo_round_judged','tdo_round_improved','tdo_completed','tdo_failed'}:
+            typer.echo(format_progress_event(event))
+            return
         if event_type in {'apprentice_attempt_started','apprentice_attempt_completed','worker_attempt_started','worker_attempt_completed','revision_started','revision_completed','mentor_review_started','mentor_review_completed','task_workspace_prepared','contribution_bundle_completed','operational_error'} or verbose:
             typer.echo(format_progress_event(event))
     return _emit
@@ -460,7 +535,7 @@ def _normalize_evaluation_mode(value: str | None) -> str | None:
         return None
     normalized=value.strip().lower().replace('_','-')
     if normalized not in EVALUATION_MODES:
-        raise typer.BadParameter(f'mentor mode must be one of: {", ".join(MENTOR_MODES)}')
+        raise typer.BadParameter(f'apprenticeship mode must be one of: {", ".join(APPRENTICESHIP_MODES)}')
     return normalized
 
 def _normalize_mentor_mode(value: str | None) -> str | None:
@@ -469,7 +544,7 @@ def _normalize_mentor_mode(value: str | None) -> str | None:
     try:
         return normalize_mentor_mode(value)
     except ValueError as exc:
-        raise typer.BadParameter(f'mentor mode must be one of: {", ".join(MENTOR_MODES)}') from exc
+        raise typer.BadParameter(f'apprenticeship mode must be one of: {", ".join(APPRENTICESHIP_MODES)}') from exc
 
 def _normalize_data_sharing(value: str | None) -> str | None:
     if value is None:
@@ -501,10 +576,33 @@ def _normalize_auto_share(value: str | None) -> str | None:
         return normalize_ecosystem_auto_share(value)
     except ValueError as exc:
         raise typer.BadParameter(
-            f'ecosystem auto-share must be one of: {", ".join(ECOSYSTEM_AUTO_SHARE_MODES)}'
+            f'legacy sharing alias must be one of: {", ".join(ECOSYSTEM_AUTO_SHARE_MODES)}'
+        ) from exc
+
+
+def _normalize_apprenticeship_mode(value: str | None) -> str | None:
+    if value is None:
+        return None
+    try:
+        return normalize_apprenticeship_mode(value)
+    except ValueError as exc:
+        raise typer.BadParameter(
+            f'apprenticeship mode must be one of: {", ".join(APPRENTICESHIP_MODES)}'
+        ) from exc
+
+
+def _normalize_training_contribution(value: str | None) -> str | None:
+    if value is None:
+        return None
+    try:
+        return normalize_training_contribution_mode(value)
+    except ValueError as exc:
+        raise typer.BadParameter(
+            f'agent training contribution mode must be one of: {", ".join(TRAINING_CONTRIBUTION_MODES)}'
         ) from exc
 
 def _settings_for_run(
+    apprenticeship_mode: str | None=None,
     mentor_mode: str | None=None,
     sensitive_info_masking: str | None=None,
     max_loops: int | None=None,
@@ -513,12 +611,15 @@ def _settings_for_run(
 ):
     settings=get_settings()
     updates={}
+    legacy_mentor_mode = _normalize_mentor_mode(mentor_mode) if mentor_mode is not None else None
+    if apprenticeship_mode is not None:
+        updates['apprenticeship_mode']=_normalize_apprenticeship_mode(apprenticeship_mode)
     if mentor_mode is not None:
-        updates['mentor_mode']=_normalize_mentor_mode(mentor_mode)
+        updates['apprenticeship_mode']=_normalize_apprenticeship_mode(mentor_mode)
     if evaluation_mode is not None:
         updates['evaluation_mode']=_normalize_evaluation_mode(evaluation_mode)
-        if mentor_mode is None:
-            updates['mentor_mode']=_normalize_mentor_mode(evaluation_mode)
+        if mentor_mode is None and apprenticeship_mode is None:
+            updates['apprenticeship_mode']=_normalize_apprenticeship_mode(evaluation_mode)
     if sensitive_info_masking is not None:
         updates['sensitive_info_masking']=_normalize_masking(sensitive_info_masking)
     if data_sharing_level is not None:
@@ -530,6 +631,12 @@ def _settings_for_run(
             raise typer.BadParameter('maximum improvement loops must be at least 1')
         updates['max_improvement_loops']=max_loops
         updates['max_iterations']=max_loops
+    if "apprenticeship_mode" in updates:
+        updates["mentor_mode"] = apprenticeship_mode_to_mentor_mode(updates["apprenticeship_mode"])
+        updates["evaluation_mode"] = mentor_mode_to_evaluation_mode(updates["mentor_mode"])
+    if legacy_mentor_mode == "hybrid" and apprenticeship_mode is None:
+        updates["mentor_mode"] = "hybrid"
+        updates["evaluation_mode"] = "hybrid"
     return settings.model_copy(update=updates)
 
 def _configure_model_impl(provider: str | None, model: str | None, api_key_env_var: str | None, test_connection: bool):
@@ -609,15 +716,15 @@ def _ensure_evaluation_ready(settings, interactive: bool=True):
     if settings.mentor_mode == 'expert_led' or model_provider_ready(settings):
         return settings
     if not interactive:
-        raise typer.BadParameter('model-assisted/hybrid Mentor Mode requires a ready Mentor Model Provider; use configure model or --mentor-mode expert-led')
+        raise typer.BadParameter('Autonomous Apprenticeship requires a ready Mentor Model Provider; use configure model or --apprenticeship-mode expert-led')
     if not _stdin_allows_prompt():
         readiness = mentor_model_provider_readiness(settings)
         reason = readiness.get("reason") or "Mentor Model Provider is not ready."
         raise typer.BadParameter(
-            f"model-assisted/hybrid Mentor Mode requires a ready Mentor Model Provider. {reason} "
-            "Run `apprentice doctor --live`, `apprentice configure model`, or use `--mentor-mode expert-led`."
+            f"Autonomous Apprenticeship requires a ready Mentor Model Provider. {reason} "
+            "Run `apprentice doctor --live`, `apprentice configure model`, or use `--apprenticeship-mode expert-led`."
         )
-    typer.echo('Model-assisted Mentor Mode needs a ready Mentor Model Provider.')
+    typer.echo('Autonomous Apprenticeship needs a ready Mentor Model Provider.')
     readiness=mentor_model_provider_readiness(settings)
     if readiness.get("provider"):
         typer.echo(_status_line('Mentor Model Provider Status', readiness.get("status"), readiness.get("reason")))
@@ -632,14 +739,14 @@ def _ensure_evaluation_ready(settings, interactive: bool=True):
     except typer.Abort:
         reason = readiness.get("reason") or "Mentor Model Provider is not ready."
         raise typer.BadParameter(
-            f"model-assisted/hybrid Mentor Mode requires a ready Mentor Model Provider. {reason} "
-            "Run `apprentice doctor --live`, `apprentice configure model`, or use `--mentor-mode expert-led`."
+            f"Autonomous Apprenticeship requires a ready Mentor Model Provider. {reason} "
+            "Run `apprentice doctor --live`, `apprentice configure model`, or use `--apprenticeship-mode expert-led`."
         ) from None
     if choice in {'1','setup','set up','configure','configure mentor model provider','set up model provider now'}:
         configured=_configure_model_impl(None, None, None, test_connection=False)
         return configured
     if choice in {'2','expert-led','expert','manual','run this session in expert-led mode'}:
-        return settings.model_copy(update={'mentor_mode':'expert_led', 'evaluation_mode':'expert-led'})
+        return settings.model_copy(update={'apprenticeship_mode':'expert_led', 'mentor_mode':'expert_led', 'evaluation_mode':'expert-led'})
     raise typer.Exit(1)
 
 
@@ -727,6 +834,7 @@ def init(
 ):
     _print_first_run_banner()
     path=init_settings(overwrite=overwrite)
+    get_or_create_ecosystem_identity(get_settings())
     typer.echo(f'initialized Agent Apprenticeship settings at {path}')
     if defaults:
         _first_run_setup(interactive=False, defaults=True)
@@ -774,7 +882,7 @@ def doctor(
     typer.echo(f'Apprentice Agent command: {agent.get("command") or "Not configured"}')
     typer.echo(f'Apprentice Agent command found: {_yes_no(bool(agent.get("command_found")))}')
     typer.echo(_status_line('Apprentice Agent readiness', agent.get('status'), agent.get('reason')))
-    typer.echo(f'Mentor Mode: {mentor_mode_display(settings.mentor_mode)}')
+    typer.echo(f'Apprenticeship Mode: {apprenticeship_mode_display(settings.apprenticeship_mode)}')
     typer.echo(f'Mentor Model Provider: {provider.get("provider_display")}')
     typer.echo(f'Mentor model: {provider.get("model") or "Not configured"}')
     typer.echo(f'API key env var: {provider.get("api_key_env_var") or "Not configured"}')
@@ -1209,13 +1317,16 @@ def configure_agent(
 
 @configure_app.command('settings')
 def configure_settings(
-    mentor_mode: str | None=typer.Option(None, '--mentor-mode', help='model-assisted, expert-led, or hybrid.'),
+    apprenticeship_mode: str | None=typer.Option(None, '--apprenticeship-mode', help='autonomous, expert-led, or org-custom.'),
+    mentor_mode: str | None=typer.Option(None, '--mentor-mode', help='Backward-compatible alias for --apprenticeship-mode.', hidden=True),
     sensitive_info_masking: str | None=typer.Option(None, '--sensitive-info-masking', help='standard or no-masking.'),
     max_loops: int | None=typer.Option(None, '--max-loops', help='Maximum improvement loops.'),
 ):
     updates={}
+    if apprenticeship_mode is not None:
+        updates['apprenticeship_mode']=_normalize_apprenticeship_mode(apprenticeship_mode)
     if mentor_mode is not None:
-        updates['mentor_mode']=_normalize_mentor_mode(mentor_mode)
+        updates['apprenticeship_mode']=_normalize_apprenticeship_mode(mentor_mode)
     if sensitive_info_masking is not None:
         updates['sensitive_info_masking']=_normalize_masking(sensitive_info_masking)
     if max_loops is not None:
@@ -1228,6 +1339,46 @@ def configure_settings(
     update_settings(**updates)
     typer.echo(public_settings_text())
 
+
+@configure_app.command('apprenticeship')
+def configure_apprenticeship(
+    mode: str | None=typer.Argument(None, help='autonomous, expert-led, or org-custom.'),
+):
+    if mode is None:
+        typer.echo("Apprenticeship Mode options:")
+        typer.echo("- autonomous: Autonomous Apprenticeship")
+        typer.echo("- expert-led: Expert-Led Apprenticeship")
+        typer.echo("- org-custom: Organization Custom")
+        mode = typer.prompt("Apprenticeship Mode")
+    normalized = _normalize_apprenticeship_mode(mode)
+    updated = update_settings(apprenticeship_mode=normalized)
+    typer.echo(f"Apprenticeship Mode: {apprenticeship_mode_display(updated.apprenticeship_mode)}")
+    if updated.apprenticeship_mode == "org_custom":
+        typer.echo("Organization Custom is available through private setup. Visit https://agentapprenticeship.org/custom")
+
+
+@configure_app.command('contribution')
+def configure_contribution(
+    mode: str | None=typer.Argument(None, help='public-ecosystem or private-internal-only.'),
+    sharing_behavior: str | None=typer.Option(None, "--sharing-behavior", help="Public Ecosystem behavior: manual or automatic."),
+):
+    if mode is None:
+        typer.echo("Agent Training Contribution Mode options:")
+        typer.echo("- public-ecosystem: share completed Experience Compilations to the Forsy ecosystem")
+        typer.echo("- private-internal-only: keep completed packages local")
+        mode = typer.prompt("Agent Training Contribution Mode")
+    normalized = _normalize_training_contribution(mode)
+    updates = {"training_contribution_mode": normalized}
+    if sharing_behavior is not None:
+        behavior = _normalize_auto_share(sharing_behavior)
+        updates["ecosystem_auto_share"] = behavior
+        if behavior != "disabled":
+            updates["training_contribution_mode"] = "public_ecosystem"
+    updated = update_settings(**updates)
+    typer.echo(f"Agent Training Contribution Mode: {training_contribution_mode_display(updated.training_contribution_mode)}")
+    if updated.training_contribution_mode == "public_ecosystem":
+        typer.echo(f"Public Ecosystem sharing behavior: {ecosystem_auto_share_display(updated.ecosystem_auto_share)}")
+
 @configure_app.command('model')
 def configure_model(
     provider: str | None=typer.Argument(None, help='Known Mentor Model Provider id.'),
@@ -1241,18 +1392,19 @@ def configure_model(
 def start(
     asset: list[Path]=typer.Option([], '--asset', '-a', help='Optional task asset file or directory.'),
     runner: str | None=typer.Option(None, '--runner', help='Advanced compatibility runner override.'),
-    mentor_mode: str | None=typer.Option(None, '--mentor-mode', help='model-assisted, expert-led, or hybrid.'),
+    apprenticeship_mode: str | None=typer.Option(None, '--apprenticeship-mode', help='autonomous, expert-led, or org-custom.'),
+    mentor_mode: str | None=typer.Option(None, '--mentor-mode', help='Backward-compatible alias for --apprenticeship-mode.', hidden=True),
     sensitive_info_masking: str | None=typer.Option(None, '--sensitive-info-masking', help='standard or no-masking.'),
-    evaluation_mode: str | None=typer.Option(None, '--evaluation-mode', help='Backward-compatible alias for --mentor-mode.'),
-    data_sharing_level: str | None=typer.Option(None, '--data-sharing-level', help='Backward-compatible alias for --sensitive-info-masking.'),
+    evaluation_mode: str | None=typer.Option(None, '--evaluation-mode', help='Backward-compatible alias for --apprenticeship-mode.', hidden=True),
+    data_sharing_level: str | None=typer.Option(None, '--data-sharing-level', help='Backward-compatible alias for --sensitive-info-masking.', hidden=True),
     max_loops: int | None=typer.Option(None, '--max-loops', help='Maximum improvement loops for this run.'),
     quiet: bool=typer.Option(False, '--quiet', help='Print only the final task result.'),
     verbose: bool=typer.Option(False, '--verbose', help='Print additional progress details when available.'),
     json_progress: bool=typer.Option(False, '--json-progress', help='Emit progress events as JSONL.'),
     expert_auto_approve: bool=typer.Option(False, '--expert-auto-approve', help='Test/dev helper: auto-approve expert-led checkpoints.'),
-    hybrid_auto_approve: bool=typer.Option(False, '--hybrid-auto-approve', help='Test/dev helper: auto-approve hybrid checkpoints.'),
+    hybrid_auto_approve: bool=typer.Option(False, '--hybrid-auto-approve', help='Compatibility test/dev helper.', hidden=True),
     expert_interactive: bool=typer.Option(False, '--expert-interactive', help='Prompt for expert-led checkpoint inputs even in non-TTY test harnesses.'),
-    hybrid_interactive: bool=typer.Option(False, '--hybrid-interactive', help='Prompt for hybrid approval inputs even in non-TTY test harnesses.'),
+    hybrid_interactive: bool=typer.Option(False, '--hybrid-interactive', help='Compatibility test/dev helper.', hidden=True),
 ):
     current_settings = get_settings()
     current_agent = apprentice_agent_readiness_status(current_settings)
@@ -1261,7 +1413,7 @@ def start(
     instruction=typer.prompt('What should your agent work on?')
     extra=typer.prompt('Add assets? optional', default='', show_default=False)
     assets=list(asset)+_split_asset_prompt(extra)
-    settings=_ensure_evaluation_ready(_settings_for_run(mentor_mode, sensitive_info_masking, max_loops, evaluation_mode, data_sharing_level), interactive=True)
+    settings=_ensure_evaluation_ready(_settings_for_run(apprenticeship_mode, mentor_mode, sensitive_info_masking, max_loops, evaluation_mode, data_sharing_level), interactive=True)
     _ensure_apprentice_agent_ready(settings, runner, interactive=True)
     interactive_checkpoints = _interactive_checkpoint_requested(
         settings,
@@ -1295,10 +1447,11 @@ def run_prompt(
     asset: list[Path]=typer.Option([], '--asset', '-a', help='Optional task asset file or directory.'),
     run_id: str | None=typer.Option(None, '--run-id', help='Optional run id/slug.'),
     runner: str | None=typer.Option(None, '--runner', help='Advanced compatibility runner override.'),
-    mentor_mode: str | None=typer.Option(None, '--mentor-mode', help='model-assisted, expert-led, or hybrid.'),
+    apprenticeship_mode: str | None=typer.Option(None, '--apprenticeship-mode', help='autonomous, expert-led, or org-custom.'),
+    mentor_mode: str | None=typer.Option(None, '--mentor-mode', help='Backward-compatible alias for --apprenticeship-mode.', hidden=True),
     sensitive_info_masking: str | None=typer.Option(None, '--sensitive-info-masking', help='standard or no-masking.'),
-    evaluation_mode: str | None=typer.Option(None, '--evaluation-mode', help='Backward-compatible alias for --mentor-mode.'),
-    data_sharing_level: str | None=typer.Option(None, '--data-sharing-level', help='Backward-compatible alias for --sensitive-info-masking.'),
+    evaluation_mode: str | None=typer.Option(None, '--evaluation-mode', help='Backward-compatible alias for --apprenticeship-mode.', hidden=True),
+    data_sharing_level: str | None=typer.Option(None, '--data-sharing-level', help='Backward-compatible alias for --sensitive-info-masking.', hidden=True),
     max_loops: int | None=typer.Option(None, '--max-loops', help='Maximum improvement loops for this run.'),
     quiet: bool=typer.Option(False, '--quiet', help='Print only the final task result.'),
     verbose: bool=typer.Option(False, '--verbose', help='Print additional progress details when available.'),
@@ -1306,12 +1459,14 @@ def run_prompt(
     experience_pack: list[str]=typer.Option([], '--experience-pack', help='Experience Pack id/path to apply to this run.'),
     no_experience_packs: bool=typer.Option(False, '--no-experience-packs', help='Do not apply Experience Packs to this run.'),
     use_active_experience_packs: bool=typer.Option(False, '--use-active-experience-packs', help='Apply active Experience Packs to this run.'),
+    use_installed_skills: bool=typer.Option(False, '--use-installed-skills', help='Force relevant installed runtime training into this run.'),
+    no_installed_skills: bool=typer.Option(False, '--no-installed-skills', help='Do not apply installed runtime training to this run.'),
     expert_auto_approve: bool=typer.Option(False, '--expert-auto-approve', help='Test/dev helper: auto-approve expert-led checkpoints.'),
-    hybrid_auto_approve: bool=typer.Option(False, '--hybrid-auto-approve', help='Test/dev helper: auto-approve hybrid checkpoints.'),
+    hybrid_auto_approve: bool=typer.Option(False, '--hybrid-auto-approve', help='Compatibility test/dev helper.', hidden=True),
     expert_interactive: bool=typer.Option(False, '--expert-interactive', help='Prompt for expert-led checkpoint inputs even in non-TTY test harnesses.'),
-    hybrid_interactive: bool=typer.Option(False, '--hybrid-interactive', help='Prompt for hybrid approval inputs even in non-TTY test harnesses.'),
+    hybrid_interactive: bool=typer.Option(False, '--hybrid-interactive', help='Compatibility test/dev helper.', hidden=True),
 ):
-    settings=_ensure_evaluation_ready(_settings_for_run(mentor_mode, sensitive_info_masking, max_loops, evaluation_mode, data_sharing_level), interactive=True)
+    settings=_ensure_evaluation_ready(_settings_for_run(apprenticeship_mode, mentor_mode, sensitive_info_masking, max_loops, evaluation_mode, data_sharing_level), interactive=True)
     _ensure_apprentice_agent_ready(settings, runner, interactive=True)
     for pack_id in experience_pack:
         try:
@@ -1327,8 +1482,26 @@ def run_prompt(
         no_packs=no_experience_packs,
         settings=settings,
     )
-    effective_instruction = instruction.rstrip() + pack_guidance if pack_guidance else instruction
+    installed_skills, runtime_guidance = ([], "")
+    if not no_installed_skills:
+        installed_skills, runtime_guidance = select_runtime_training_for_run(
+            instruction,
+            settings=settings,
+            force=use_installed_skills,
+        )
+        if installed_skills and not quiet and not json_progress:
+            typer.echo("Installed Runtime Training selected:")
+            for skill in installed_skills:
+                typer.echo(f"- {skill.get('installed_skill_id')}: {skill.get('title')}")
+    effective_instruction = instruction.rstrip()
+    if pack_guidance:
+        effective_instruction += pack_guidance
+    if runtime_guidance:
+        effective_instruction += runtime_guidance
+    if effective_instruction == instruction.rstrip():
+        effective_instruction = instruction
     experience_refs = pack_run_refs(selected_packs)
+    runtime_refs = installed_skill_run_refs(installed_skills)
     interactive_checkpoints = _interactive_checkpoint_requested(
         settings,
         expert_auto_approve=expert_auto_approve,
@@ -1350,6 +1523,7 @@ def run_prompt(
                 runner=runner,
                 progress_callback=_progress_callback(quiet, verbose, json_progress),
                 experience_pack_refs=experience_refs,
+                runtime_training_refs=runtime_refs,
             )
         except RunInterrupted as exc:
             if not quiet and not json_progress:
@@ -1369,15 +1543,15 @@ def continue_run(
     followup_instruction: str | None=typer.Argument(None, help='Optional direct follow-up instruction.'),
     asset: list[Path]=typer.Option([], '--asset', '-a', help='Optional follow-up asset file or directory.'),
     run_loop: bool=typer.Option(False, '--run-loop', help='Run another improvement loop after recording the follow-up.'),
-    record_only: bool=typer.Option(False, '--record-only', '--no-run-loop', help='Only record the follow-up and update the Contribution Bundle.'),
+    record_only: bool=typer.Option(False, '--record-only', '--no-run-loop', help='Only record the follow-up and update the Experience Compilation.'),
     runner: str | None=typer.Option(None, '--runner', help='Advanced compatibility runner override.'),
     quiet: bool=typer.Option(False, '--quiet', help='Print only the final task result.'),
     verbose: bool=typer.Option(False, '--verbose', help='Print additional progress details when available.'),
     json_progress: bool=typer.Option(False, '--json-progress', help='Emit progress events as JSONL.'),
     expert_interactive: bool=typer.Option(False, '--expert-interactive', help='Prompt for expert-led checkpoint inputs even in non-TTY test harnesses.'),
-    hybrid_interactive: bool=typer.Option(False, '--hybrid-interactive', help='Prompt for hybrid approval inputs even in non-TTY test harnesses.'),
+    hybrid_interactive: bool=typer.Option(False, '--hybrid-interactive', help='Compatibility test/dev helper.', hidden=True),
     expert_auto_approve: bool=typer.Option(False, '--expert-auto-approve', help='Test/dev helper: auto-approve expert-led checkpoints.'),
-    hybrid_auto_approve: bool=typer.Option(False, '--hybrid-auto-approve', help='Test/dev helper: auto-approve hybrid checkpoints.'),
+    hybrid_auto_approve: bool=typer.Option(False, '--hybrid-auto-approve', help='Compatibility test/dev helper.', hidden=True),
 ):
     settings=get_settings()
     run_root=run_root_for(run_id, settings)
@@ -1429,7 +1603,7 @@ def continue_run(
                 typer.echo("")
                 typer.echo("Follow-up interrupted.")
                 if previous_status.get("contribution_bundle_path"):
-                    typer.echo("Previous Contribution Bundle:")
+                    typer.echo("Previous Experience Compilation:")
                     typer.echo(str(previous_status.get("contribution_bundle_path")))
             raise typer.Exit(130)
     status = read_run_status(run_root)
@@ -1443,9 +1617,9 @@ def finish(
     quiet: bool=typer.Option(False, '--quiet', help='Print only the final task result.'),
     json_progress: bool=typer.Option(False, '--json-progress', help='Emit progress events as JSONL.'),
     expert_interactive: bool=typer.Option(False, '--expert-interactive', help='Prompt for expert-led final checkpoint inputs even in non-TTY test harnesses.'),
-    hybrid_interactive: bool=typer.Option(False, '--hybrid-interactive', help='Prompt for hybrid final checkpoint inputs even in non-TTY test harnesses.'),
+    hybrid_interactive: bool=typer.Option(False, '--hybrid-interactive', help='Compatibility test/dev helper.', hidden=True),
     expert_auto_approve: bool=typer.Option(False, '--expert-auto-approve', help='Test/dev helper: auto-approve expert-led checkpoints.'),
-    hybrid_auto_approve: bool=typer.Option(False, '--hybrid-auto-approve', help='Test/dev helper: auto-approve hybrid checkpoints.'),
+    hybrid_auto_approve: bool=typer.Option(False, '--hybrid-auto-approve', help='Compatibility test/dev helper.', hidden=True),
 ):
     settings = get_settings()
     interactive_checkpoints = _interactive_checkpoint_requested(
@@ -1460,7 +1634,7 @@ def finish(
         hybrid_auto_approve=hybrid_auto_approve,
         mentor_interactive_checkpoints=interactive_checkpoints,
     ):
-        run_root,bundle=finish_session(run_id, settings=settings)
+        run_root,bundle=finish_session(run_id, settings=settings, progress_callback=None if json_progress else _progress_callback(quiet, False, False))
     status=read_run_status(run_root)
     if json_progress:
         for event in read_jsonl(run_root/'progress_events.jsonl'):
@@ -1533,6 +1707,8 @@ def _ecosystem_status() -> dict:
     repo_path = _configured_ecosystem_repo_path()
     gh_installed = bool(_gh_path())
     gh_authed = _gh_authenticated() if gh_installed else False
+    settings = get_settings()
+    r2 = r2_status(settings)
     return {
         "repo": repo,
         "repo_url": _ecosystem_repo_url(repo),
@@ -1541,10 +1717,22 @@ def _ecosystem_status() -> dict:
         "gh_installed": gh_installed,
         "gh_authenticated": gh_authed,
         "automatic_contribution_ready": bool(repo and gh_installed and gh_authed),
+        **r2,
     }
 
 
 def _ecosystem_auto_share_readiness(repo: str | None = None) -> dict:
+    settings = get_settings()
+    if settings.ecosystem_storage_backend == "forsy-r2":
+        api_url = r2_api_url(settings)
+        return {
+            "ready": bool(api_url),
+            "reason": None if api_url else "R2 ingestion API is not configured",
+            "next_action": "apprentice ecosystem configure --r2-api-url <url>" if not api_url else None,
+            "repo": _configured_ecosystem_repo(),
+            "repo_url": _ecosystem_repo_url(),
+            "storage_backend": "forsy-r2",
+        }
     configured_repo = repo or _configured_ecosystem_repo() or DEFAULT_PUBLIC_ECOSYSTEM_REPO
     gh_installed = bool(_gh_path())
     gh_authed = _gh_authenticated() if gh_installed else False
@@ -1592,13 +1780,15 @@ def _ecosystem_auto_share_readiness(repo: str | None = None) -> dict:
 def _ecosystem_auto_share_status_line(settings=None) -> str:
     s = settings or get_settings()
     readiness = _ecosystem_auto_share_readiness()
-    label = ecosystem_auto_share_display(s.ecosystem_auto_share)
-    if s.ecosystem_auto_share == "manual":
-        return f"Ecosystem Auto-Share: {label}"
+    label = training_contribution_mode_display(s.training_contribution_mode)
+    if s.training_contribution_mode == "private_internal_only":
+        return f"Agent Training Contribution Mode: {label}"
+    behavior = ecosystem_auto_share_display(s.ecosystem_auto_share)
+    behavior_label = "automatic" if behavior == "automatic" else "manual"
     if readiness["ready"]:
-        return f"Ecosystem Auto-Share: {label}\nEcosystem Auto-Share Status: Ready"
+        return f"Agent Training Contribution Mode: {label}\nPublic Ecosystem sharing behavior: {behavior_label}\nPublic Ecosystem upload status: Ready"
     reason = readiness.get("reason") or "not ready"
-    return f"Ecosystem Auto-Share: {label}\nEcosystem Auto-Share Status: Not ready - {reason}"
+    return f"Agent Training Contribution Mode: {label}\nPublic Ecosystem sharing behavior: {behavior_label}\nPublic Ecosystem upload status: Not ready - {reason}"
 
 
 def _public_settings_text_with_ecosystem() -> str:
@@ -1618,7 +1808,7 @@ def _public_settings_text_with_ecosystem() -> str:
             out.append(f"GitHub URL: {_ecosystem_repo_url(settings.ecosystem_repo)}")
             out.append(git_line)
             inserted = True
-        if line.startswith("Ecosystem Auto-Share:"):
+        if line.startswith("Agent Training Contribution Mode:"):
             out.pop()
             out.extend(auto_status)
     if not inserted:
@@ -1901,8 +2091,16 @@ def _load_registry_file(path: Path) -> list[dict]:
     return [row for row in rows if isinstance(row, dict)]
 
 
-def _load_registry(registry: Path | None=None) -> list[dict]:
+def _load_registry(registry: Path | None=None, storage: str | None = None) -> list[dict]:
     if registry is None:
+        backend = normalize_ecosystem_storage(storage or get_settings().ecosystem_storage_backend)
+        if backend == "forsy-r2":
+            try:
+                return fetch_r2_index(get_settings())
+            except FileNotFoundError as exc:
+                raise FileNotFoundError(f"{exc} Fallback: apprentice ecosystem list --storage github") from exc
+            except Exception as exc:
+                raise FileNotFoundError(f"R2 ecosystem index could not be read. {redact_secrets(str(exc))} Fallback: apprentice ecosystem list --storage github") from exc
         repo_path = _configured_ecosystem_repo_path()
         if repo_path:
             return _index_from_public_repo_path(repo_path)
@@ -1943,20 +2141,67 @@ def _load_registry(registry: Path | None=None) -> list[dict]:
     return _load_registry_file(path)
 
 
+def _row_id(row: dict) -> str:
+    return str(row.get("id") or row.get("bundle_id") or row.get("package_id") or row.get("seed_task_id") or row.get("task_id") or "")
+
+
+def _row_values(row: dict, *keys: str) -> list[str]:
+    values: list[str] = []
+    for key in keys:
+        value = row.get(key)
+        if isinstance(value, (list, tuple, set)):
+            values.extend(str(item) for item in value if item not in (None, ""))
+        elif isinstance(value, dict):
+            values.extend(str(item) for item in value.values() if item not in (None, ""))
+        elif value not in (None, ""):
+            values.append(str(value))
+    return values
+
+
+def _row_contains(row: dict, expected: str, *keys: str) -> bool:
+    needle = str(expected or "").strip().lower()
+    return bool(needle) and any(needle == value.lower() or needle in value.lower() for value in _row_values(row, *keys))
+
+
 def _matches_registry_row(row: dict, query: str | None, filters: dict) -> bool:
+    if filters.get("mine"):
+        identity = get_or_create_ecosystem_identity(get_settings())
+        contributor = row.get("contributor") or {}
+        if str(contributor.get("ecosystem_user_id") or "") != str(identity.get("ecosystem_user_id")):
+            return False
     if query:
-        haystack=' '.join(str(row.get(k) or '') for k in ['bundle_id','title','agent_apprentice_role','expected_economic_value'])
-        haystack+=' '+' '.join(str(v) for v in row.get('domains') or [])
-        haystack+=' '+' '.join(str(v) for v in row.get('subdomains') or [])
+        haystack=' '.join(_row_values(
+            row,
+            'id', 'item_id', 'bundle_id', 'package_id', 'experience_compilation_id',
+            'title', 'task_title', 'summary', 'agent_apprentice_role',
+            'expected_economic_value', 'economic_value_summary',
+            'domain', 'domains', 'subdomain', 'subdomains', 'tags', 'surfaces', 'tools',
+        ))
         if query.lower() not in haystack.lower():
             return False
-    for key in ['title','mentor_mode','task_status','run_status']:
+    if filters.get("apprenticeship_mode"):
+        expected = _normalize_apprenticeship_mode(str(filters["apprenticeship_mode"]))
+        actual = row.get("apprenticeship_mode")
+        if not actual and row.get("mentor_mode"):
+            actual = normalize_apprenticeship_mode(str(row.get("mentor_mode")))
+        if not actual:
+            return False
+        if normalize_apprenticeship_mode(str(actual or "")) != expected:
+            return False
+    for key in ['title','task_status','run_status']:
         value=filters.get(key)
         if value and str(row.get(key) or '').lower() != str(value).lower():
             return False
-    for key, field in [('domain','domains'), ('subdomain','subdomains')]:
+    if filters.get("mentor_mode"):
+        expected = _normalize_apprenticeship_mode(str(filters["mentor_mode"]))
+        actual = row.get("apprenticeship_mode") or row.get("mentor_mode")
+        if not actual:
+            return False
+        if normalize_apprenticeship_mode(str(actual or "")) != expected:
+            return False
+    for key, fields in [('domain', ('domain', 'domains')), ('subdomain', ('subdomain', 'subdomains')), ('tag', ('tags',))]:
         value=filters.get(key)
-        if value and value.lower() not in [str(v).lower() for v in row.get(field) or []]:
+        if value and not _row_contains(row, str(value), *fields):
             return False
     if filters.get('min_traced_steps') is not None and int(row.get('traced_steps') or 0) < filters['min_traced_steps']:
         return False
@@ -1987,12 +2232,51 @@ def _matches_registry_row(row: dict, query: str | None, filters: dict) -> bool:
     return True
 
 
-def _print_registry_rows(rows: list[dict]) -> None:
+def _select_registry_row(rows: list[dict]) -> None:
+    if not sys.stdin.isatty():
+        typer.echo("Selection requires an interactive terminal. Use `--json` to select an item non-interactively.")
+        return
+    choice = typer.prompt("Choose Experience Compilation", default="1").strip()
+    try:
+        index = int(choice)
+    except ValueError:
+        typer.echo("Selection cancelled.")
+        return
+    if index < 1 or index > len(rows):
+        typer.echo("Selection cancelled.")
+        return
+    row = rows[index - 1]
+    item_id = _row_id(row)
+    typer.echo("")
+    typer.echo("Choose action:")
+    typer.echo("1. Export Full Experience Compilation")
+    typer.echo("2. Install Runtime Training")
+    action = typer.prompt("Action", default="1").strip()
+    if action == "1":
+        output = typer.prompt("Output path", default=str(get_settings().app_home / "ecosystem" / "exports" / item_id)).strip()
+        package_root = _package_for_ecosystem_item(item_id)
+        exported = _copy_or_zip_package(package_root, Path(output), item_id=item_id, source="ecosystem_select")
+        typer.echo(f"Export Full Experience Compilation complete: {exported}")
+    elif action == "2":
+        package_root = _package_for_ecosystem_item(item_id)
+        manifest = install_runtime_training_from_bundle(item_id, package_root, settings=get_settings())
+        typer.echo("Install Runtime Training complete.")
+        typer.echo(f"installed_skill_id: {manifest.get('installed_skill_id')}")
+    else:
+        typer.echo("Selection cancelled.")
+
+
+def _print_registry_rows(rows: list[dict], *, json_output: bool = False, select: bool = False) -> None:
+    if json_output:
+        typer.echo(json.dumps({"items": sanitize_public_obj(rows)}, indent=2, sort_keys=True))
+        return
     if not rows:
-        typer.echo('No ecosystem bundles matched.')
+        typer.echo('No Experience Compilations matched.')
         return
-    for row in rows:
-        typer.echo(_format_registry_row(row))
+    for index, row in enumerate(rows, 1):
+        typer.echo(_format_registry_row(row, index=index))
+    if select:
+        _select_registry_row(rows)
 
 
 def _is_seed_registry_row(row: dict) -> bool:
@@ -2003,7 +2287,7 @@ def _format_count(value) -> str:
     return str(int(value)) if isinstance(value, (int, float)) or str(value).isdigit() else "0"
 
 
-def _format_seed_registry_row(row: dict) -> str:
+def _format_seed_registry_row(row: dict, *, index: int | None = None) -> str:
     bundle_id = row.get("bundle_id") or row.get("seed_task_id") or row.get("task_id")
     status = row.get("task_status") or "ready_to_run"
     run_status = row.get("run_status") or "not_run"
@@ -2025,34 +2309,46 @@ def _format_seed_registry_row(row: dict) -> str:
     if row.get("revision_preference_pairs") is not None:
         details.append(f"preferences: {_format_count(row.get('revision_preference_pairs'))}")
     details.append(learning_label)
-    return f"{bundle_id}: {row.get('title')} [{' · '.join(details)}]"
+    prefix = f"{index}. " if index is not None else ""
+    return f"{prefix}{bundle_id}: {row.get('title')} [{' · '.join(details)}]"
 
 
-def _format_registry_row(row: dict) -> str:
+def _format_registry_row(row: dict, *, index: int | None = None) -> str:
     if _is_seed_registry_row(row):
-        return _format_seed_registry_row(row)
+        return _format_seed_registry_row(row, index=index)
     details = [
         str(row.get("task_status") or row.get("run_status") or "status_unknown"),
     ]
-    if row.get("mentor_mode"):
-        details.append(f"mentor_mode={mentor_mode_display(row.get('mentor_mode'))}")
+    mode = row.get("apprenticeship_mode") or row.get("mentor_mode")
+    if mode:
+        details.append(f"apprenticeship_mode={apprenticeship_mode_display(normalize_apprenticeship_mode(str(mode)))}")
     traces = row.get("traced_steps")
     if traces is not None:
         details.append(f"traces: {_format_count(traces)}")
     artifacts = row.get("artifact_count")
     if artifacts is not None:
         details.append(f"artifacts: {_format_count(artifacts)}")
-    return (
-        f"{row.get('bundle_id')}: {row.get('title')} "
-        f"[{' · '.join(details)}]"
-    )
+    summary = str(row.get("summary") or "").strip()
+    if len(summary) > 180:
+        summary = summary[:177].rstrip() + "..."
+    prefix = f"{index}. " if index is not None else ""
+    return "\n".join([
+        f"{prefix}{row.get('title') or _row_id(row)}",
+        f"   item_id: {_row_id(row)}",
+        f"   domain: {row.get('domain') or 'unknown'}",
+        f"   subdomain: {row.get('subdomain') or 'unknown'}",
+        f"   expected economic value: {row.get('expected_economic_value') or 'unknown'}",
+        f"   summary: {summary or 'No summary provided.'}",
+        f"   details: {' · '.join(details)}",
+        "   actions: 1. Export Full Experience Compilation  2. Install Runtime Training",
+    ])
 
 
 def _safe_bundle_path(path: Path) -> Path:
     bundle = path.expanduser()
     manifest = bundle / "contribution_manifest.json"
     if not manifest.exists():
-        raise FileNotFoundError(f"Contribution Bundle manifest not found: {manifest}")
+        raise FileNotFoundError(f"Experience Compilation manifest not found: {manifest}")
     return bundle
 
 
@@ -2103,6 +2399,7 @@ def _bundle_submission_metadata(bundle: Path, package_name: str | None = None, p
         "task_status": manifest.get("task_status"),
         "run_status": manifest.get("run_status"),
         "apprentice_agent": session.get("apprentice_agent"),
+        "apprenticeship_mode": manifest.get("apprenticeship_mode") or session.get("apprenticeship_mode"),
         "mentor_mode": manifest.get("mentor_mode"),
         "mentor_model_provider": session.get("model_provider"),
         "domains": manifest.get("domains") or [],
@@ -2150,7 +2447,7 @@ def _submission_summary(metadata: dict, bundle: Path, package_zip: Path | None =
         f"Task Status: {metadata.get('task_status')}",
         f"Run Status: {metadata.get('run_status')}",
         f"Apprentice Agent: {metadata.get('apprentice_agent') or 'unknown'}",
-        f"Mentor Mode: {mentor_mode_display(metadata.get('mentor_mode'))}",
+        f"Apprenticeship Mode: {apprenticeship_mode_display(metadata.get('apprenticeship_mode') or metadata.get('mentor_mode'))}",
         f"Mentor Model Provider: {metadata.get('mentor_model_provider') or 'none'}",
         f"Attempts: {metadata.get('attempts')}",
         f"Traced Steps: {metadata.get('traced_steps')}",
@@ -2238,12 +2535,12 @@ def _sanitize_submission_copy(root: Path) -> None:
             path.write_text(sanitize_public_text(raw) or "")
 
 
-def _create_ecosystem_submission(bundle: Path) -> tuple[Path, Path, dict]:
+def _create_ecosystem_submission(bundle: Path, *, block_secret_like_values: bool = False) -> tuple[Path, Path, dict]:
     bundle = _safe_bundle_path(bundle)
     secret_hits = _bundle_secret_hits(bundle)
-    if secret_hits:
+    if block_secret_like_values and secret_hits:
         raise RuntimeError(
-            "Obvious secret-like values were found in the Contribution Bundle. "
+            "Obvious secret-like values were found in the Experience Compilation. "
             "Remove or regenerate the affected files before public contribution: "
             + ", ".join(secret_hits[:10])
         )
@@ -2280,6 +2577,7 @@ def _ecosystem_contribution_record(
     return {
         "bundle_id": metadata.get("bundle_id"),
         "auto_share_mode": auto_share_mode,
+        "training_contribution_mode": auto_share_mode,
         "contribution_created": contribution_created,
         "contribution_url": contribution_url,
         "contribution_method": contribution_method,
@@ -2301,10 +2599,15 @@ def _ecosystem_contribute_impl(
     repo: str | None = None,
     dry_run: bool = False,
     auto_share_mode: str = "manual",
+    storage: str | None = None,
+    qa: bool = False,
 ) -> dict:
     bundle = _safe_bundle_path(bundle_path)
+    qa = qa or str(os.environ.get("AA_R2_QA_UPLOAD") or "").strip().lower() in {"1", "true", "yes", "on"}
     submission_dir, package_zip, metadata = _create_ecosystem_submission(bundle)
     target_repo = repo or _configured_ecosystem_repo()
+    settings = get_settings()
+    storage_backend = normalize_ecosystem_storage(storage or settings.ecosystem_storage_backend or DEFAULT_ECOSYSTEM_STORAGE_BACKEND)
     issue_body = _gh_issue_body(metadata, submission_dir, package_zip)
     result = {
         "bundle": bundle,
@@ -2313,14 +2616,84 @@ def _ecosystem_contribute_impl(
         "metadata": metadata,
         "issue_body": issue_body,
         "target_repo": target_repo,
+        "storage_backend": storage_backend,
+        "storage_ref": None,
+        "ecosystem_item": None,
+        "upload_response": None,
         "contribution_created": False,
         "contribution_url": None,
         "contribution_method": "manual_package",
         "skipped_reason": None,
         "gh_error": None,
     }
+
+    if storage_backend == "forsy-r2":
+        identity = get_or_create_ecosystem_identity(settings)
+        item = ecosystem_item_from_bundle(bundle, metadata, settings=settings, identity=identity, source="qa" if qa else "contribution")
+        storage_ref = storage_ref_for_item(item, settings=settings, dry_run=dry_run)
+        write_storage_ref(bundle, submission_dir, storage_ref)
+        _zip_dir(submission_dir, package_zip)
+        result["ecosystem_item"] = item
+        result["storage_ref"] = storage_ref
+        result["contribution_method"] = "r2_worker_ingestion" if not dry_run else "r2_worker_dry_run"
+        if dry_run:
+            result["skipped_reason"] = "dry run"
+        else:
+            api_url = r2_api_url(settings)
+            if not api_url:
+                result["skipped_reason"] = "R2 ingestion API is not configured"
+                result["contribution_method"] = "skipped"
+            else:
+                response = upload_contribution_to_worker(
+                    api_url=api_url,
+                    package_zip=package_zip,
+                    ecosystem_item=item,
+                    manifest=read_json(bundle / "contribution_manifest.json"),
+                    storage_ref=storage_ref,
+                    qa=qa,
+                )
+                result["upload_response"] = response
+                result["contribution_created"] = response.get("status") == "ok"
+                result["contribution_url"] = (
+                    (response.get("storage") or {}).get("url")
+                    or storage_ref.get("url")
+                    or (api_url.rstrip("/") + f"/v1/ecosystem/items/{item.get('id')}")
+                )
+                response_storage = response.get("storage") if isinstance(response.get("storage"), dict) else {}
+                if response_storage:
+                    item["storage"] = {**(item.get("storage") or {}), **response_storage}
+                uploaded_ref = storage_ref_for_item(
+                    item,
+                    settings=settings,
+                    dry_run=False,
+                    uploaded_at=datetime.now(timezone.utc).isoformat(),
+                    url=result["contribution_url"],
+                )
+                write_storage_ref(bundle, submission_dir, uploaded_ref)
+                _zip_dir(submission_dir, package_zip)
+                result["storage_ref"] = uploaded_ref
+                append_successful_share(
+                    item=item,
+                    bundle=bundle,
+                    storage_backend="forsy-r2",
+                    url=result["contribution_url"],
+                    sharing_mode=auto_share_mode,
+                    settings=settings,
+                )
+        record = _ecosystem_contribution_record(
+            metadata=metadata,
+            auto_share_mode=auto_share_mode,
+            contribution_created=bool(result["contribution_created"]),
+            contribution_url=result.get("contribution_url"),
+            contribution_method=str(result["contribution_method"]),
+            skipped_reason=result.get("skipped_reason"),
+        )
+        result["record"] = record
+        _write_ecosystem_contribution_record(bundle, record)
+        return result
+
     if target_repo and _gh_path() and _gh_authenticated() and not dry_run:
-        title = f"Contribution Bundle: {metadata.get('bundle_id')}"
+        title = f"Experience Compilation: {metadata.get('bundle_id')}"
         cp = _run_gh(["issue", "create", "--repo", target_repo, "--title", title, "--body-file", str(issue_body)], timeout=60)
         if cp.returncode == 0:
             result["contribution_created"] = True
@@ -2356,12 +2729,12 @@ def _bundle_from_status(status: dict) -> Path | None:
 
 
 def _print_auto_share_summary(metadata: dict) -> None:
-    typer.echo("Contribution Bundle summary")
+    typer.echo("Experience Compilation summary")
     typer.echo(f"bundle_id: {metadata.get('bundle_id')}")
     typer.echo(f"title: {metadata.get('title')}")
     typer.echo(f"task_status: {metadata.get('task_status')}")
     typer.echo(f"Apprentice Agent: {metadata.get('apprentice_agent') or 'unknown'}")
-    typer.echo(f"Mentor Mode: {mentor_mode_display(metadata.get('mentor_mode'))}")
+    typer.echo(f"Apprenticeship Mode: {apprenticeship_mode_display(metadata.get('apprenticeship_mode') or metadata.get('mentor_mode'))}")
     typer.echo(f"Mentor Model Provider: {metadata.get('mentor_model_provider') or 'none'}")
     typer.echo(f"artifact_count: {metadata.get('artifact_count')}")
 
@@ -2381,28 +2754,32 @@ def _record_auto_share_skip(bundle: Path, *, mode: str, reason: str) -> None:
 
 def _handle_ecosystem_auto_share(status: dict, *, quiet: bool = False, json_progress: bool = False) -> None:
     settings = get_settings()
-    mode = settings.ecosystem_auto_share
-    if mode == "manual":
+    mode = settings.training_contribution_mode
+    if mode == "private_internal_only":
         return
     bundle = _bundle_from_status(status)
     if bundle is None:
         return
     emit = not quiet and not json_progress
-    if mode == "automatic":
-        readiness = _ecosystem_auto_share_readiness()
-        if not readiness["ready"]:
-            reason = str(readiness.get("reason") or "not ready")
-            _record_auto_share_skip(bundle, mode=mode, reason=reason)
-            if emit:
-                typer.echo("")
-                typer.echo(f"Ecosystem Auto-Share skipped - {reason}")
-                typer.echo("Ecosystem Auto-Share is configured for:")
-                typer.echo(str(readiness.get("repo_url") or _ecosystem_repo_url()))
-                if readiness.get("next_action"):
+    if mode == "public_ecosystem":
+        behavior = normalize_ecosystem_auto_share(settings.ecosystem_auto_share)
+        if behavior == "manual":
+            if not emit or not sys.stdin.isatty():
+                _record_auto_share_skip(bundle, mode=mode, reason="manual sharing behavior; upload not confirmed")
+                if emit:
                     typer.echo("")
-                    typer.echo("Run:")
-                    typer.echo(str(readiness["next_action"]))
-            return
+                    typer.echo("Public Ecosystem upload: manual; no upload was made.")
+                    typer.echo(f"Experience Compilation: {bundle}")
+                    typer.echo(f"Retry: apprentice ecosystem contribute {bundle}")
+                return
+            typer.echo("")
+            typer.echo("Share this Experience Compilation to the Forsy ecosystem? [y/N]")
+            choice = typer.prompt("Share", default="N", show_default=False).strip().lower()
+            if choice not in {"y", "yes"}:
+                _record_auto_share_skip(bundle, mode=mode, reason="user chose not to share")
+                typer.echo("Kept local package only.")
+                typer.echo(f"Retry: apprentice ecosystem contribute {bundle}")
+                return
         try:
             result = _ecosystem_contribute_impl(bundle, auto_share_mode=mode)
         except Exception as exc:
@@ -2410,77 +2787,23 @@ def _handle_ecosystem_auto_share(status: dict, *, quiet: bool = False, json_prog
             _record_auto_share_skip(bundle, mode=mode, reason=reason)
             if emit:
                 typer.echo("")
-                typer.echo("Ecosystem Auto-Share skipped - safety check failed")
+                typer.echo("Public Ecosystem upload skipped - package could not be prepared")
                 typer.echo(f"Reason: {reason}")
-                typer.echo(f"Bundle: {bundle}")
+                typer.echo(f"Experience Compilation: {bundle}")
+                typer.echo(f"Retry: apprentice ecosystem contribute {bundle}")
             return
         if emit:
             typer.echo("")
             if result["contribution_created"]:
-                typer.echo(f"Public ecosystem contribution created: {result['contribution_url']}")
+                typer.echo("Agent Training Contribution Mode: Public Ecosystem")
+                typer.echo("Uploading Experience Compilation to Forsy ecosystem...")
+                typer.echo(f"Uploaded: {result['contribution_url']}")
             else:
                 reason = result.get("skipped_reason") or "public contribution was not created"
-                typer.echo(f"Ecosystem Auto-Share skipped - {reason}")
-                typer.echo(f"Bundle: {bundle}")
+                typer.echo(f"Public Ecosystem upload skipped - {reason}")
+                typer.echo(f"Experience Compilation: {bundle}")
+                typer.echo(f"Retry: apprentice ecosystem contribute {bundle}")
         return
-    if mode == "ask":
-        try:
-            submission_dir, package_zip, metadata = _create_ecosystem_submission(bundle)
-            _gh_issue_body(metadata, submission_dir, package_zip)
-        except Exception as exc:
-            reason = redact_secrets(str(exc))
-            _record_auto_share_skip(bundle, mode=mode, reason=reason)
-            if emit:
-                typer.echo("")
-                typer.echo("Ecosystem Auto-Share skipped - safety check failed")
-                typer.echo(f"Reason: {reason}")
-                typer.echo(f"Bundle: {bundle}")
-            return
-        if not emit:
-            _record_auto_share_skip(bundle, mode=mode, reason="ask mode requires interactive output")
-            return
-        while True:
-            typer.echo("")
-            typer.echo("Share this Contribution Bundle to the public ecosystem now?")
-            typer.echo("")
-            typer.echo("1. Share now")
-            typer.echo("2. Skip")
-            typer.echo("3. Show submission summary")
-            choice = typer.prompt("Default", default="skip").strip().lower()
-            if choice in {"1", "share", "share now", "yes", "y"}:
-                readiness = _ecosystem_auto_share_readiness()
-                if not readiness["ready"]:
-                    reason = str(readiness.get("reason") or "not ready")
-                    _record_auto_share_skip(bundle, mode=mode, reason=reason)
-                    typer.echo(f"Ecosystem Auto-Share skipped - {reason}")
-                    typer.echo("Ecosystem Auto-Share is configured for:")
-                    typer.echo(str(readiness.get("repo_url") or _ecosystem_repo_url()))
-                    if readiness.get("next_action"):
-                        typer.echo("")
-                        typer.echo("Run:")
-                        typer.echo(str(readiness["next_action"]))
-                    return
-                try:
-                    result = _ecosystem_contribute_impl(bundle, auto_share_mode=mode)
-                except Exception as exc:
-                    reason = redact_secrets(str(exc))
-                    _record_auto_share_skip(bundle, mode=mode, reason=reason)
-                    typer.echo("Ecosystem Auto-Share skipped - safety check failed")
-                    typer.echo(f"Reason: {reason}")
-                    typer.echo(f"Bundle: {bundle}")
-                    return
-                if result["contribution_created"]:
-                    typer.echo(f"Public ecosystem contribution created: {result['contribution_url']}")
-                else:
-                    typer.echo(f"Ecosystem Auto-Share skipped - {result.get('skipped_reason') or 'public contribution was not created'}")
-                    typer.echo(f"Share later: apprentice ecosystem contribute {bundle}")
-                return
-            if choice in {"3", "summary", "show", "show submission summary"}:
-                _print_auto_share_summary(metadata)
-                continue
-            _record_auto_share_skip(bundle, mode=mode, reason="user skipped")
-            typer.echo(f"Share later: apprentice ecosystem contribute {bundle}")
-            return
 
 
 def _gh_issue_body(metadata: dict, submission_dir: Path, package_zip: Path) -> Path:
@@ -2519,11 +2842,12 @@ def learn_search(query: str | None = typer.Argument(None, help="Search ecosystem
 
 @learn_app.command("create")
 def learn_create(
-    sources: list[str] = typer.Argument(..., help="Ecosystem ids or local Contribution Bundle paths."),
+    sources: list[str] = typer.Argument(..., help="Ecosystem ids or local Experience Compilation paths."),
     title: str | None = typer.Option(None, "--title", help="Optional Experience Pack title."),
     replay: bool = typer.Option(False, "--replay", help="Run before/after replay after creating the pack."),
     runner: str | None = typer.Option(None, "--runner", help="Advanced compatibility runner override for replay."),
-    mentor_mode: str = typer.Option("expert-led", "--mentor-mode", help="Mentor Mode for replay, default expert-led."),
+    apprenticeship_mode: str = typer.Option("expert-led", "--apprenticeship-mode", help="Apprenticeship Mode for replay."),
+    mentor_mode: str | None = typer.Option(None, "--mentor-mode", help="Backward-compatible alias for --apprenticeship-mode.", hidden=True),
 ):
     settings = get_settings()
     resolved = [resolve_learning_source(source, settings) for source in sources]
@@ -2537,7 +2861,7 @@ def learn_create(
     typer.echo(f"- apprentice learn preview {pack.get('pack_id')}")
     typer.echo(f"- apprentice learn replay {pack.get('pack_id')}")
     if replay:
-        _learn_replay_impl(str(pack.get("pack_id")), runner=runner, mentor_mode=mentor_mode)
+        _learn_replay_impl(str(pack.get("pack_id")), runner=runner, apprenticeship_mode=mentor_mode or apprenticeship_mode)
 
 
 @learn_app.command("preview")
@@ -2565,8 +2889,8 @@ def learn_preview(pack_id: str = typer.Argument(..., help="Experience Pack id or
             typer.echo(f"- {requirement}")
 
 
-def _learn_replay_impl(pack_id: str, *, runner: str | None, mentor_mode: str) -> dict:
-    settings = _settings_for_run(mentor_mode, None, 1, None, None)
+def _learn_replay_impl(pack_id: str, *, runner: str | None, apprenticeship_mode: str) -> dict:
+    settings = _settings_for_run(apprenticeship_mode=apprenticeship_mode, max_loops=1)
     _ensure_apprentice_agent_ready(settings, runner, interactive=False)
     pack_path, pack = load_pack(pack_id, settings)
     instruction = replay_instruction_for_pack(pack, settings)
@@ -2621,9 +2945,10 @@ def _learn_replay_impl(pack_id: str, *, runner: str | None, mentor_mode: str) ->
 def learn_replay(
     pack_id: str = typer.Argument(..., help="Experience Pack id or path."),
     runner: str | None = typer.Option(None, "--runner", help="Advanced compatibility runner override."),
-    mentor_mode: str = typer.Option("expert-led", "--mentor-mode", help="Mentor Mode for replay, default expert-led."),
+    apprenticeship_mode: str = typer.Option("expert-led", "--apprenticeship-mode", help="Apprenticeship Mode for replay."),
+    mentor_mode: str | None = typer.Option(None, "--mentor-mode", help="Backward-compatible alias for --apprenticeship-mode.", hidden=True),
 ):
-    _learn_replay_impl(pack_id, runner=runner, mentor_mode=mentor_mode)
+    _learn_replay_impl(pack_id, runner=runner, apprenticeship_mode=mentor_mode or apprenticeship_mode)
 
 
 @learn_app.command("keep")
@@ -2670,25 +2995,104 @@ def learn_status():
         typer.echo(f"- {pack.get('pack_id')}: {pack.get('title')}")
 
 
+@learn_app.command("install")
+def learn_install(
+    item_id: str=typer.Argument(..., help="Ecosystem item id or local Experience Compilation path."),
+    dry_run: bool=typer.Option(False, "--dry-run", help="Show what would be installed without writing files."),
+    agent_target: str=typer.Option("current", "--agent-target", help="current, codex, claude, cursor, opencode, openclaw, hermes, or custom."),
+    registry: Path | None=typer.Option(None, "--registry", help="Public ecosystem index JSON path for offline/test use."),
+    storage: str | None=typer.Option(None, "--storage", help="Storage backend: forsy-r2 or github."),
+):
+    source_path = Path(item_id).expanduser()
+    try:
+        if source_path.exists():
+            package = source_path
+            source = str(source_path.name)
+        else:
+            package = _package_for_ecosystem_item(item_id, registry=registry, storage=storage)
+            source = item_id
+        result = install_runtime_training_from_bundle(source, package, settings=get_settings(), agent_target=agent_target, dry_run=dry_run)
+    except Exception as exc:
+        typer.echo(f"Could not install runtime training: {redact_secrets(str(exc))}")
+        raise typer.Exit(1)
+    if dry_run:
+        typer.echo("Install Runtime Training dry run complete.")
+        typer.echo(f"installed_skill_id: {result.get('installed_skill_id')}")
+        typer.echo(f"target: {result.get('target')}")
+        typer.echo("No files were installed.")
+        return
+    typer.echo("Install Runtime Training complete.")
+    typer.echo(f"installed_skill_id: {result.get('installed_skill_id')}")
+    typer.echo(f"enabled: {str(result.get('enabled')).lower()}")
+    typer.echo("registry: local Agent Apprenticeship runtime")
+
+
+@learn_app.command("installed")
+def learn_installed(json_output: bool=typer.Option(False, "--json", help="Print installed runtime training as JSON.")):
+    rows = list_installed_skills(get_settings())
+    if json_output:
+        typer.echo(json.dumps(rows, indent=2, sort_keys=True))
+        return
+    if not rows:
+        typer.echo("Installed Runtime Training: none")
+        return
+    typer.echo("Installed Runtime Training")
+    for row in rows:
+        status = "enabled" if row.get("enabled", True) else "disabled"
+        typer.echo(f"- {row.get('installed_skill_id')}: {row.get('title')} [{status}]")
+
+
+@learn_app.command("enable")
+def learn_enable(installed_skill_id: str=typer.Argument(..., help="Installed runtime training id.")):
+    try:
+        row = set_installed_skill_enabled(installed_skill_id, True, get_settings())
+    except FileNotFoundError as exc:
+        typer.echo(str(exc))
+        raise typer.Exit(1)
+    typer.echo("Runtime training enabled.")
+    typer.echo(f"installed_skill_id: {row.get('installed_skill_id')}")
+
+
+@learn_app.command("disable")
+def learn_disable(installed_skill_id: str=typer.Argument(..., help="Installed runtime training id.")):
+    try:
+        row = set_installed_skill_enabled(installed_skill_id, False, get_settings())
+    except FileNotFoundError as exc:
+        typer.echo(str(exc))
+        raise typer.Exit(1)
+    typer.echo("Runtime training disabled.")
+    typer.echo(f"installed_skill_id: {row.get('installed_skill_id')}")
+
+
+@learn_app.command("uninstall")
+def learn_uninstall(installed_skill_id: str=typer.Argument(..., help="Installed runtime training id.")):
+    try:
+        uninstall_installed_skill(installed_skill_id, get_settings())
+    except FileNotFoundError as exc:
+        typer.echo(str(exc))
+        raise typer.Exit(1)
+    typer.echo("Runtime training uninstalled.")
+    typer.echo("registry: local Agent Apprenticeship runtime")
+
+
 @ecosystem_app.command('guide')
 def ecosystem_guide():
     typer.echo('Agent Apprenticeship Ecosystem')
     typer.echo('')
-    typer.echo('The public ecosystem is the open-source Agent Apprenticeship ecosystem repo.')
-    typer.echo('Run a task, then contribute the generated Contribution Bundle:')
+    typer.echo('The public ecosystem stores shared Experience Compilations in Forsy Cloudflare R2.')
+    typer.echo('Run a task, then share the generated Experience Compilation:')
     typer.echo('  apprentice ecosystem contribute <bundle_path>')
     typer.echo('')
-    typer.echo('Configure the public ecosystem repo:')
-    typer.echo(f'  default: {DEFAULT_PUBLIC_ECOSYSTEM_REPO}')
-    typer.echo('  apprentice ecosystem configure --repo <owner>/<repo>')
-    typer.echo('  apprentice ecosystem configure --repo-path <public-ecosystem-repo-checkout>')
+    typer.echo('Configure ecosystem storage:')
+    typer.echo('  apprentice ecosystem configure --storage forsy-r2')
+    typer.echo('  apprentice ecosystem configure --r2-api-url <worker-url>')
     typer.echo('')
-    typer.echo('Ecosystem Auto-Share is Manual by default.')
-    typer.echo('  apprentice ecosystem configure --auto-share ask')
-    typer.echo('  apprentice ecosystem configure --auto-share automatic')
+    typer.echo('Agent Training Contribution Mode is Public Ecosystem by default.')
+    typer.echo('  apprentice ecosystem configure --training-contribution public-ecosystem')
+    typer.echo('  apprentice ecosystem configure --training-contribution private-internal-only')
     typer.echo('')
-    typer.echo('If GitHub CLI automation is unavailable, the contribute command prepares a local submission package and copy-paste-ready public issue text.')
-    typer.echo('Remote ecosystem sync is not included in v0. Public repo discovery works through the configured repo when `gh` can read its index; `--registry` can point at an exported public index JSON for tests or offline use.')
+    typer.echo('Legacy GitHub issue sharing remains available only with:')
+    typer.echo('  apprentice ecosystem contribute <bundle_path> --storage github')
     typer.echo(f'Community Slack: {SLACK_LINK}')
 
 
@@ -2696,28 +3100,40 @@ def ecosystem_guide():
 def ecosystem_configure(
     repo: str | None=typer.Option(None, '--repo', help='Public ecosystem repo in owner/name form.'),
     repo_path: Path | None=typer.Option(None, '--repo-path', help='Public ecosystem repo path for a local checkout/export.'),
-    auto_share: str | None=typer.Option(None, '--auto-share', help='Ecosystem Auto-Share mode: manual, ask, or automatic.'),
+    apprenticeship_mode: str | None=typer.Option(None, '--apprenticeship-mode', help='autonomous, expert-led, or org-custom.'),
+    training_contribution: str | None=typer.Option(None, '--training-contribution', help='public-ecosystem or private-internal-only.'),
+    sharing_behavior: str | None=typer.Option(None, '--sharing-behavior', help='Public Ecosystem behavior: manual or automatic.'),
+    auto_share: str | None=typer.Option(None, '--auto-share', help='Deprecated alias for --training-contribution.', hidden=True),
+    storage: str | None=typer.Option(None, '--storage', help='Storage backend: forsy-r2 or github.'),
+    r2_api_url: str | None=typer.Option(None, '--r2-api-url', help='Forsy R2 Worker ingestion API URL.'),
+    r2_bucket: str | None=typer.Option(None, '--r2-bucket', help='R2 bucket name.'),
+    r2_index_prefix: str | None=typer.Option(None, '--r2-index-prefix', help='R2 index prefix.'),
+    r2_contribution_prefix: str | None=typer.Option(None, '--r2-contribution-prefix', help='R2 Experience Compilation storage prefix.'),
+    r2_seed_prefix: str | None=typer.Option(None, '--r2-seed-prefix', help='R2 seed dataset prefix.'),
 ):
     settings = get_settings()
-    if repo is None and repo_path is None and auto_share is None:
+    if all(v is None for v in [repo, repo_path, apprenticeship_mode, training_contribution, sharing_behavior, auto_share, storage, r2_api_url, r2_bucket, r2_index_prefix, r2_contribution_prefix, r2_seed_prefix]):
         status = _ecosystem_status()
         typer.echo("Public Ecosystem Configuration")
+        typer.echo(f"Storage backend: {settings.ecosystem_storage_backend}")
+        typer.echo(f"R2 ingestion API: {settings.r2_api_url or 'not configured'}")
+        typer.echo(f"R2 bucket: {settings.r2_bucket}")
         typer.echo(f"Current repo: {settings.ecosystem_repo or DEFAULT_PUBLIC_ECOSYSTEM_REPO}")
         typer.echo(f"GitHub URL: {_ecosystem_repo_url(settings.ecosystem_repo)}")
         typer.echo(f"Current public ecosystem repo path: {settings.ecosystem_repo_path or 'Not configured'}")
         typer.echo(f"GitHub CLI installed: {_yes_no(status['gh_installed'])}")
         typer.echo(f"GitHub CLI authenticated: {_yes_no(status['gh_authenticated'])}")
-        typer.echo(f"Current Ecosystem Auto-Share: {ecosystem_auto_share_display(settings.ecosystem_auto_share)}")
+        typer.echo(f"Current Apprenticeship Mode: {apprenticeship_mode_display(settings.apprenticeship_mode)}")
+        typer.echo(f"Current Agent Training Contribution Mode: {training_contribution_mode_display(settings.training_contribution_mode)}")
         entered_repo = typer.prompt("Public ecosystem repo, owner/name, optional", default=settings.ecosystem_repo or DEFAULT_PUBLIC_ECOSYSTEM_REPO, show_default=False).strip()
         if entered_repo:
             repo = entered_repo
         typer.echo("")
-        typer.echo("Choose Ecosystem Auto-Share mode:")
-        typer.echo("1. Manual")
-        typer.echo("2. Ask before sharing")
-        typer.echo("3. Share automatically")
-        choice = typer.prompt("Default", default=settings.ecosystem_auto_share).strip().lower()
-        auto_share = {"1": "manual", "2": "ask", "3": "automatic"}.get(choice, choice)
+        typer.echo("Choose Agent Training Contribution Mode:")
+        typer.echo("1. Public Ecosystem")
+        typer.echo("2. Private Internal Only")
+        choice = typer.prompt("Default", default=settings.training_contribution_mode).strip().lower()
+        training_contribution = {"1": "public_ecosystem", "2": "private_internal_only"}.get(choice, choice)
     updates = {}
     candidate_repo = repo or settings.ecosystem_repo or DEFAULT_PUBLIC_ECOSYSTEM_REPO
     if repo is not None:
@@ -2734,23 +3150,31 @@ def ecosystem_configure(
             typer.echo(f"Public ecosystem repo path does not look like an Agent Apprenticeship ecosystem repo: {expanded}")
             raise typer.Exit(1)
         updates["ecosystem_repo_path"] = expanded
+    if apprenticeship_mode is not None:
+        updates["apprenticeship_mode"] = _normalize_apprenticeship_mode(apprenticeship_mode)
+    if training_contribution is not None:
+        updates["training_contribution_mode"] = _normalize_training_contribution(training_contribution)
+    if sharing_behavior is not None:
+        updates["ecosystem_auto_share"] = _normalize_auto_share(sharing_behavior)
+        if _normalize_auto_share(sharing_behavior) != "disabled":
+            updates["training_contribution_mode"] = "public_ecosystem"
+        else:
+            updates["training_contribution_mode"] = "private_internal_only"
     if auto_share is not None:
-        mode = _normalize_auto_share(auto_share)
-        if mode in {"ask", "automatic"}:
-            readiness = _ecosystem_auto_share_readiness(candidate_repo)
-            if not readiness["ready"]:
-                typer.echo("Ecosystem Auto-Share cannot be enabled yet.")
-                typer.echo("")
-                typer.echo("Ecosystem Auto-Share is configured for:")
-                typer.echo(str(readiness.get("repo_url") or _ecosystem_repo_url(candidate_repo)))
-                typer.echo("")
-                typer.echo("Required:")
-                next_action = str(readiness.get("next_action") or "gh auth login")
-                typer.echo(f"- {next_action}")
-                if readiness.get("reason"):
-                    typer.echo(f"Reason: {readiness['reason']}")
-                raise typer.Exit(1)
-        updates["ecosystem_auto_share"] = mode
+        updates["ecosystem_auto_share"] = _normalize_auto_share(auto_share)
+        updates["training_contribution_mode"] = "public_ecosystem" if _normalize_auto_share(auto_share) != "disabled" else "private_internal_only"
+    if storage is not None:
+        updates["ecosystem_storage_backend"] = normalize_ecosystem_storage(storage)
+    if r2_api_url is not None:
+        updates["r2_api_url"] = r2_api_url.rstrip("/")
+    if r2_bucket is not None:
+        updates["r2_bucket"] = r2_bucket
+    if r2_index_prefix is not None:
+        updates["r2_index_prefix"] = r2_index_prefix.strip("/")
+    if r2_contribution_prefix is not None:
+        updates["r2_contribution_prefix"] = r2_contribution_prefix.strip("/")
+    if r2_seed_prefix is not None:
+        updates["r2_seed_prefix"] = r2_seed_prefix.strip("/")
     if not updates:
         typer.echo("No ecosystem settings changed.")
         return
@@ -2759,8 +3183,21 @@ def ecosystem_configure(
         typer.echo(f"Public ecosystem repo configured: {repo}")
     if repo_path is not None:
         typer.echo(f"Public ecosystem repo path configured: {Path(repo_path).expanduser()}")
-    if auto_share is not None:
-        typer.echo(f"Ecosystem Auto-Share: {ecosystem_auto_share_display(updated.ecosystem_auto_share)}")
+    if apprenticeship_mode is not None:
+        typer.echo(f"Apprenticeship Mode: {apprenticeship_mode_display(updated.apprenticeship_mode)}")
+    if training_contribution is not None or sharing_behavior is not None or auto_share is not None:
+        typer.echo(f"Agent Training Contribution Mode: {training_contribution_mode_display(updated.training_contribution_mode)}")
+        if updated.training_contribution_mode == "public_ecosystem":
+            typer.echo(f"Public Ecosystem sharing behavior: {ecosystem_auto_share_display(updated.ecosystem_auto_share)}")
+    if storage is not None:
+        typer.echo(f"Storage backend: {updated.ecosystem_storage_backend}")
+    if r2_api_url is not None:
+        typer.echo(f"R2 ingestion API: {updated.r2_api_url or 'not configured'}")
+    if any(v is not None for v in [r2_bucket, r2_index_prefix, r2_contribution_prefix, r2_seed_prefix]):
+        typer.echo(f"R2 bucket: {updated.r2_bucket}")
+        typer.echo(f"R2 index prefix: {updated.r2_index_prefix}")
+        typer.echo(f"R2 Experience Compilation prefix: {updated.r2_contribution_prefix}")
+        typer.echo(f"R2 seed prefix: {updated.r2_seed_prefix}")
     typer.echo("Next: apprentice ecosystem status")
 
 
@@ -2769,32 +3206,116 @@ def ecosystem_status_command():
     status = _ecosystem_status()
     settings = get_settings()
     typer.echo("Public Ecosystem Status")
-    typer.echo(f"Public Ecosystem Repo: {status['repo'] or DEFAULT_PUBLIC_ECOSYSTEM_REPO}")
+    typer.echo(f"Storage backend: {status['storage_backend']}")
+    typer.echo(f"R2 ingestion API: {status.get('r2_api_url') or 'not configured'}")
+    typer.echo(f"R2 bucket: {status['r2_bucket']}")
+    typer.echo(f"R2 index prefix: {status['r2_index_prefix']}")
+    typer.echo(f"R2 Experience Compilation prefix: {status['r2_contribution_prefix']}")
+    typer.echo(f"R2 seed prefix: {status['r2_seed_prefix']}")
+    typer.echo(f"GitHub fallback repo: {status['repo'] or DEFAULT_PUBLIC_ECOSYSTEM_REPO}")
     typer.echo(f"GitHub URL: {status['repo_url']}")
     typer.echo(f"Public ecosystem repo path: {status.get('repo_path') or 'Not configured'}")
     if status.get("repo_path"):
         typer.echo(f"Public ecosystem repo path exists: {_yes_no(status.get('repo_path_exists'))}")
     typer.echo(f"GitHub CLI installed: {_yes_no(status['gh_installed'])}")
     typer.echo(f"GitHub CLI authenticated: {_yes_no(status['gh_authenticated'])}")
-    typer.echo(f"Automatic public contribution: {_yes_no(status['automatic_contribution_ready'])}")
-    typer.echo(f"Ecosystem Auto-Share: {ecosystem_auto_share_display(settings.ecosystem_auto_share)}")
-    if settings.ecosystem_auto_share != "manual":
+    typer.echo(f"Apprenticeship Mode: {apprenticeship_mode_display(settings.apprenticeship_mode)}")
+    typer.echo(f"Agent Training Contribution Mode: {training_contribution_mode_display(settings.training_contribution_mode)}")
+    typer.echo(f"Local ecosystem user: {status.get('ecosystem_user_id')}")
+    typer.echo(f"Shared contributions: {status.get('shared_count', 0)}")
+    if settings.training_contribution_mode == "public_ecosystem":
         readiness = _ecosystem_auto_share_readiness()
-        typer.echo(f"Ecosystem Auto-Share Status: {'Ready' if readiness['ready'] else 'Not ready - ' + str(readiness.get('reason') or 'not ready')}")
-    if not status["gh_installed"]:
-        typer.echo("Next: install GitHub CLI (`gh`) or use `apprentice ecosystem contribute <bundle>` for manual submission files.")
-    elif not status["gh_authenticated"]:
-        typer.echo("Next: run `gh auth login`, or use the manual submission package generated by `apprentice ecosystem contribute <bundle>`.")
+        typer.echo(f"Public Ecosystem upload status: {'Ready' if readiness['ready'] else 'Not ready - ' + str(readiness.get('reason') or 'not ready')}")
+
+
+@ecosystem_app.command('identity')
+def ecosystem_identity():
+    settings = get_settings()
+    identity = get_or_create_ecosystem_identity(settings)
+    typer.echo("Local ecosystem identity")
+    typer.echo(f"ecosystem_user_id: {identity.get('ecosystem_user_id')}")
+    typer.echo(f"installation_id: {identity.get('installation_id')}")
+    typer.echo(f"created_at: {identity.get('created_at')}")
+    typer.echo(f"shared_contributions: {len(shared_history(settings))}")
+
+
+def _print_shared_rows(rows: list[dict[str, Any]]) -> None:
+    if not rows:
+        typer.echo("No shared Experience Compilations recorded yet.")
+        return
+    for row in rows:
+        typer.echo(f"{row.get('item_id')}: {row.get('title')} [{row.get('storage_backend')} · {row.get('uploaded_at')}]")
+
+
+@ecosystem_shared_app.callback(invoke_without_command=True)
+def ecosystem_shared(
+    ctx: typer.Context,
+    json_output: bool = typer.Option(False, "--json", help="Print local shared Experience Compilation history as JSON."),
+):
+    if ctx.invoked_subcommand is not None:
+        return
+    rows = shared_history(get_settings())
+    if json_output:
+        typer.echo(json.dumps(rows, indent=2, sort_keys=True))
+        return
+    _print_shared_rows(rows)
+
+
+def _local_shared_record(item_id: str) -> dict[str, Any]:
+    for row in shared_history(get_settings()):
+        if item_id in {str(row.get("item_id") or ""), str(row.get("package_id") or "")}:
+            return row
+    raise FileNotFoundError(f"Shared contribution not found locally: {item_id}")
+
+
+@ecosystem_shared_app.command("inspect")
+def ecosystem_shared_inspect(item_id: str = typer.Argument(...)):
+    try:
+        row = _local_shared_record(item_id)
+    except FileNotFoundError as exc:
+        typer.echo(str(exc))
+        raise typer.Exit(1)
+    typer.echo(f"item_id: {row.get('item_id')}")
+    typer.echo(f"package_id: {row.get('package_id')}")
+    typer.echo(f"title: {row.get('title')}")
+    typer.echo(f"storage_backend: {row.get('storage_backend')}")
+    typer.echo(f"url: {row.get('url')}")
+    typer.echo(f"local_bundle_path: {row.get('local_bundle_path')}")
+
+
+@ecosystem_shared_app.command("pull")
+def ecosystem_shared_pull(item_id: str = typer.Argument(...)):
+    try:
+        row = _local_shared_record(item_id)
+    except FileNotFoundError as exc:
+        typer.echo(str(exc))
+        raise typer.Exit(1)
+    local = Path(str(row.get("local_bundle_path") or "")).expanduser()
+    dest = _prepare_ecosystem_pull_destination(str(row.get("item_id") or item_id))
+    if local.exists():
+        if dest.exists():
+            shutil.rmtree(dest)
+        shutil.copytree(local, dest)
+        typer.echo(f"pulled_bundle={dest}")
+        return
+    try:
+        download_r2_package(str(row.get("item_id") or item_id), dest, get_settings())
+    except Exception as exc:
+        typer.echo(f"Could not pull shared Experience Compilation: {redact_secrets(str(exc))}")
+        raise typer.Exit(1)
+    typer.echo(f"pulled_bundle={dest}")
 
 
 @ecosystem_app.command('contribute')
 def ecosystem_contribute(
-    bundle_path: Path=typer.Argument(..., help='Contribution Bundle folder.'),
+    bundle_path: Path=typer.Argument(..., help='Experience Compilation folder.'),
     repo: str | None=typer.Option(None, '--repo', help='Public ecosystem repo in owner/name form.'),
-    dry_run: bool=typer.Option(False, '--dry-run', help='Prepare files and show the GitHub command without creating an issue.'),
+    dry_run: bool=typer.Option(False, '--dry-run', help='Prepare upload package without uploading.'),
+    storage: str | None=typer.Option(None, '--storage', help='Storage backend: forsy-r2 or github.'),
+    qa: bool=typer.Option(False, '--qa', help='Use QA storage path when supported.'),
 ):
     try:
-        result = _ecosystem_contribute_impl(bundle_path, repo=repo, dry_run=dry_run, auto_share_mode="manual")
+        result = _ecosystem_contribute_impl(bundle_path, repo=repo, dry_run=dry_run, auto_share_mode="manual", storage=storage, qa=qa)
     except Exception as exc:
         typer.echo(f"Could not prepare public ecosystem contribution: {redact_secrets(str(exc))}")
         raise typer.Exit(1)
@@ -2804,7 +3325,52 @@ def ecosystem_contribute(
     metadata = result["metadata"]
     target_repo = result["target_repo"]
     issue_body = result["issue_body"]
-    typer.echo("Public ecosystem contribution prepared.")
+    if result.get("storage_backend") == "forsy-r2":
+        item = result.get("ecosystem_item") or {}
+        storage_ref = result.get("storage_ref") or {}
+        if dry_run:
+            typer.echo("Forsy ecosystem upload dry run complete.")
+            typer.echo("No files were uploaded.")
+            typer.echo("")
+            typer.echo("Storage backend:")
+            typer.echo("Cloudflare R2")
+            typer.echo("")
+            typer.echo("Ingestion API:")
+            typer.echo(str(storage_ref.get("ingestion_api_url") or "not configured"))
+            typer.echo("")
+            typer.echo("Local ecosystem user:")
+            typer.echo(str(storage_ref.get("ecosystem_user_id")))
+            typer.echo("")
+            typer.echo("Prepared package:")
+            typer.echo(str(package_zip))
+            typer.echo("")
+            typer.echo("Storage reference:")
+            typer.echo("ecosystem_submission/storage_ref.json")
+            return
+        if result["contribution_created"]:
+            typer.echo("Experience Compilation uploaded to the Forsy ecosystem.")
+            typer.echo("")
+            typer.echo("Item:")
+            typer.echo(str(item.get("id")))
+            typer.echo("")
+            typer.echo("Local ecosystem user:")
+            typer.echo(str(storage_ref.get("ecosystem_user_id")))
+            typer.echo("")
+            typer.echo("Storage:")
+            typer.echo(f"Cloudflare R2 / {(item.get('storage') or {}).get('path_prefix')}")
+            typer.echo("")
+            typer.echo("URL:")
+            typer.echo(str(result["contribution_url"]))
+            return
+        typer.echo("Forsy ecosystem upload package prepared.")
+        typer.echo(f"Reason upload did not run: {result.get('skipped_reason') or 'not uploaded'}")
+        typer.echo(f"Prepared package: {package_zip}")
+        typer.echo("Storage reference: ecosystem_submission/storage_ref.json")
+        typer.echo("Retry after configuring the Worker URL:")
+        typer.echo("apprentice ecosystem configure --r2-api-url <url>")
+        return
+
+    typer.echo("Legacy GitHub ecosystem contribution prepared.")
     typer.echo("")
     typer.echo(f"Bundle ID: {metadata.get('bundle_id')}")
     typer.echo(f"Title: {metadata.get('title')}")
@@ -2820,9 +3386,9 @@ def ecosystem_contribute(
         typer.echo(str(result.get("gh_error") or ""))
     elif target_repo and _gh_path() and _gh_authenticated() and dry_run:
         typer.echo("Dry run: no GitHub issue was created.")
-        typer.echo(f"Would run: gh issue create --repo {target_repo} --title \"Contribution Bundle: {metadata.get('bundle_id')}\" --body-file GITHUB_ISSUE_BODY.md")
+        typer.echo(f"Would run: gh issue create --repo {target_repo} --title \"Experience Compilation: {metadata.get('bundle_id')}\" --body-file GITHUB_ISSUE_BODY.md")
     else:
-        typer.echo("No upload was performed in v0.")
+        typer.echo("No GitHub issue was created.")
         typer.echo(f"Public ecosystem: {_ecosystem_repo_url(target_repo)}")
         if not _gh_path():
             typer.echo("GitHub CLI `gh` is not installed.")
@@ -2837,13 +3403,25 @@ def ecosystem_contribute(
 
 
 @ecosystem_app.command('list')
-def ecosystem_list(registry: Path | None=typer.Option(None, '--registry', help='Public ecosystem index JSON path for offline/test use.')):
+def ecosystem_list(
+    registry: Path | None=typer.Option(None, '--registry', help='Public ecosystem index JSON path for offline/test use.'),
+    storage: str | None=typer.Option(None, '--storage', help='Storage backend: forsy-r2 or github.'),
+    mine: bool=typer.Option(False, '--mine', help='Show items shared by this local ecosystem user.'),
+    domain: str | None=typer.Option(None, '--domain', help='Filter by domain.'),
+    subdomain: str | None=typer.Option(None, '--subdomain', help='Filter by subdomain.'),
+    tag: str | None=typer.Option(None, '--tag', help='Filter by tag.'),
+    json_output: bool=typer.Option(False, '--json', help='Print matching Experience Compilations as JSON.'),
+):
     try:
-        rows=_load_registry(registry)
+        rows=_load_registry(registry, storage=storage)
     except FileNotFoundError as exc:
         typer.echo(str(exc))
         raise typer.Exit(1)
-    _print_registry_rows(rows)
+    if mine:
+        rows = [row for row in rows if _matches_registry_row(row, None, {"mine": True})]
+    filters = {"domain": domain, "subdomain": subdomain, "tag": tag}
+    rows = [row for row in rows if _matches_registry_row(row, None, filters)]
+    _print_registry_rows(rows, json_output=json_output)
 
 
 @ecosystem_app.command('search')
@@ -2851,21 +3429,27 @@ def ecosystem_search(
     query_arg: str | None=typer.Argument(None, help='Free-text query.'),
     query: str | None=typer.Option(None, '--query', help='Free-text query.'),
     registry: Path | None=typer.Option(None, '--registry', help='Public ecosystem index JSON path for offline/test use.'),
+    storage: str | None=typer.Option(None, '--storage', help='Storage backend: forsy-r2 or github.'),
+    mine: bool=typer.Option(False, '--mine', help='Search items shared by this local ecosystem user.'),
     title: str | None=typer.Option(None, '--title'),
     domain: str | None=typer.Option(None, '--domain'),
     subdomain: str | None=typer.Option(None, '--subdomain'),
-    mentor_mode: str | None=typer.Option(None, '--mentor-mode'),
+    apprenticeship_mode: str | None=typer.Option(None, '--apprenticeship-mode', help='autonomous, expert-led, or org-custom.'),
+    mentor_mode: str | None=typer.Option(None, '--mentor-mode', help='Backward-compatible alias for --apprenticeship-mode.', hidden=True),
     task_status: str | None=typer.Option(None, '--task-status'),
     run_status: str | None=typer.Option(None, '--run-status'),
     min_traced_steps: int | None=typer.Option(None, '--min-traced-steps'),
     max_traced_steps: int | None=typer.Option(None, '--max-traced-steps'),
     expected_economic_value: str | None=typer.Option(None, '--expected-economic-value'),
+    tag: str | None=typer.Option(None, '--tag'),
     artifact_type: str | None=typer.Option(None, '--artifact-type'),
     apprentice_agent: str | None=typer.Option(None, '--apprentice-agent'),
     mentor_model_provider: str | None=typer.Option(None, '--mentor-model-provider'),
+    json_output: bool=typer.Option(False, '--json', help='Print matching Experience Compilations as JSON.'),
+    select: bool=typer.Option(False, '--select', help='Interactively choose a matching Experience Compilation and action.'),
 ):
     try:
-        rows=_load_registry(registry)
+        rows=_load_registry(registry, storage=storage)
     except FileNotFoundError as exc:
         typer.echo(str(exc))
         raise typer.Exit(1)
@@ -2874,14 +3458,25 @@ def ecosystem_search(
     filters.pop('query_arg', None)
     filters.pop('query', None)
     filters.pop('registry', None)
+    filters.pop('storage', None)
     filters.pop('effective_query', None)
-    _print_registry_rows([row for row in rows if _matches_registry_row(row, effective_query, filters)])
+    filters["mine"] = mine
+    if mentor_mode and not apprenticeship_mode:
+        filters["apprenticeship_mode"] = mentor_mode
+    _print_registry_rows([row for row in rows if _matches_registry_row(row, effective_query, filters)], json_output=json_output, select=select)
 
 
-def _find_registry_row(bundle_id: str, registry: Path | None=None) -> dict:
-    rows=_load_registry(registry)
+def _find_registry_row(bundle_id: str, registry: Path | None=None, storage: str | None = None) -> dict:
+    rows=_load_registry(registry, storage=storage)
     for row in rows:
-        if row.get('bundle_id') == bundle_id:
+        ids = {
+            str(row.get("id") or ""),
+            str(row.get("bundle_id") or ""),
+            str(row.get("package_id") or ""),
+            str(row.get("seed_task_id") or ""),
+            str(row.get("task_id") or ""),
+        }
+        if bundle_id in ids:
             return row
     raise FileNotFoundError(f'Bundle id not found in registry: {bundle_id}')
 
@@ -2901,16 +3496,113 @@ def _prepare_ecosystem_pull_destination(bundle_id: str) -> Path:
     return dest
 
 
+def _locate_package_root(path: Path) -> Path:
+    path = path.expanduser()
+    if path.is_file():
+        path = path.parent
+    candidates = [path, path / "contribution_bundle", path / "package"]
+    for candidate in candidates:
+        if (candidate / "contribution_manifest.json").exists() or (candidate / "experience_compiler").exists():
+            return candidate
+    for manifest in path.rglob("contribution_manifest.json"):
+        return manifest.parent
+    return path
+
+
+def _copy_or_zip_package(src: Path, output: Path, *, item_id: str, source: str) -> Path:
+    src = _locate_package_root(src)
+    output = output.expanduser()
+    manifest = {
+        "export_type": "full_experience_compilation",
+        "item_id": item_id,
+        "source": source,
+        "exported_at": datetime.now(timezone.utc).isoformat(),
+        "package_root": "package",
+        "includes": [
+            "traces",
+            "attempts",
+            "artifacts",
+            "outputs",
+            "evaluation",
+            "learning_signals",
+            "experience_compiler",
+            "skill_pack",
+            "runtime_learning_package",
+            "training_time_package",
+            "environment",
+            "manifests",
+        ],
+    }
+    if output.suffix == ".zip":
+        staging = output.parent / f".{output.stem}-export"
+        if staging.exists():
+            shutil.rmtree(staging)
+        (staging / "package").mkdir(parents=True)
+        shutil.copytree(src, staging / "package", dirs_exist_ok=True)
+        write_json(staging / "export_manifest.json", manifest)
+        _zip_dir(staging, output)
+        shutil.rmtree(staging)
+        return output
+    if output.exists():
+        shutil.rmtree(output)
+    output.mkdir(parents=True)
+    shutil.copytree(src, output / "package", dirs_exist_ok=True)
+    write_json(output / "export_manifest.json", manifest)
+    return output
+
+
+def _package_for_ecosystem_item(item_id: str, *, registry: Path | None = None, storage: str | None = None) -> Path:
+    direct = Path(item_id).expanduser()
+    if direct.exists():
+        return _locate_package_root(direct)
+    local = get_settings().app_home / "ecosystem" / "bundles" / item_id
+    if local.exists():
+        return _locate_package_root(local)
+    backend = normalize_ecosystem_storage(storage or get_settings().ecosystem_storage_backend)
+    if backend == "forsy-r2" and registry is None:
+        dest = _prepare_ecosystem_pull_destination(item_id)
+        download_r2_package(item_id, dest, get_settings())
+        return _locate_package_root(dest)
+    row = _find_registry_row(item_id, registry, storage=storage)
+    src = row.get("local_bundle_path") or row.get("path") or row.get("bundle_path") or row.get("bundle_path_or_url")
+    if src and Path(str(src)).expanduser().exists():
+        return _locate_package_root(Path(str(src)).expanduser())
+    raise FileNotFoundError(f"No full package is available for ecosystem item: {item_id}")
+
+
 @ecosystem_app.command('pull')
 def ecosystem_pull(
     bundle_id: str=typer.Argument(...),
     registry: Path | None=typer.Option(None, '--registry', help='Public ecosystem index JSON path for offline/test use.'),
+    storage: str | None=typer.Option(None, '--storage', help='Storage backend: forsy-r2 or github.'),
+    full: bool=typer.Option(False, '--full', help='Export the Full Experience Compilation after pulling.'),
+    runtime: bool=typer.Option(False, '--runtime', help='Pull runtime training subset for install.'),
+    install: bool=typer.Option(False, '--install', help='Install runtime training after pulling.'),
+    mode: str | None=typer.Option(None, '--mode', help='full or runtime.'),
 ):
     try:
-        row=_find_registry_row(bundle_id, registry)
+        row=_find_registry_row(bundle_id, registry, storage=storage)
     except FileNotFoundError as exc:
         typer.echo(str(exc))
         raise typer.Exit(1)
+    backend = normalize_ecosystem_storage(storage or get_settings().ecosystem_storage_backend)
+    if backend == "forsy-r2" and not registry:
+        dest=_prepare_ecosystem_pull_destination(_row_id(row) or bundle_id)
+        try:
+            download_r2_package(str(row.get("id") or bundle_id), dest, get_settings())
+        except Exception as exc:
+            typer.echo(f"Could not pull ecosystem item from R2: {redact_secrets(str(exc))}")
+            typer.echo("Fallback: apprentice ecosystem pull " + bundle_id + " --storage github")
+            raise typer.Exit(1)
+        typer.echo(f'pulled_bundle={dest}')
+        if full or mode == "full":
+            export_path = _copy_or_zip_package(dest, get_settings().app_home / "ecosystem" / "exports" / (_row_id(row) or bundle_id), item_id=_row_id(row) or bundle_id, source="r2_pull")
+            typer.echo(f"full_experience_compilation={export_path}")
+        if install or runtime or mode == "runtime":
+            manifest = install_runtime_training_from_bundle(_row_id(row) or bundle_id, dest, settings=get_settings())
+            typer.echo("Runtime training installed.")
+            typer.echo(f"installed_skill_id: {manifest.get('installed_skill_id')}")
+        return
     src=row.get('local_bundle_path') or row.get('path') or row.get('bundle_path') or row.get('bundle_path_or_url')
     if not src:
         task_path = row.get("task_path") or row.get("task_packet_path")
@@ -2978,6 +3670,39 @@ def ecosystem_pull(
         typer.echo('Next action: set AA_HOME to a writable directory and try again.')
         raise typer.Exit(1)
     typer.echo(f'pulled_bundle={dest}')
+    if full or mode == "full":
+        export_path = _copy_or_zip_package(dest, get_settings().app_home / "ecosystem" / "exports" / bundle_id, item_id=bundle_id, source="local_pull")
+        typer.echo(f"full_experience_compilation={export_path}")
+    if install or runtime or mode == "runtime":
+        try:
+            manifest = install_runtime_training_from_bundle(bundle_id, dest, settings=get_settings())
+        except Exception as exc:
+            typer.echo(f"Could not install runtime training: {redact_secrets(str(exc))}")
+            raise typer.Exit(1)
+        typer.echo("Runtime training installed.")
+        typer.echo(f"installed_skill_id: {manifest.get('installed_skill_id')}")
+
+
+@ecosystem_app.command('export')
+def ecosystem_export(
+    item_id: str=typer.Argument(..., help='Ecosystem item id.'),
+    output: Path=typer.Option(..., '--output', '-o', help='Output folder or .zip path.'),
+    full: bool=typer.Option(False, '--full', help='Export the Full Experience Compilation.'),
+    mode: str | None=typer.Option(None, '--mode', help='Export mode: full.'),
+    registry: Path | None=typer.Option(None, '--registry', help='Public ecosystem index JSON path for offline/test use.'),
+    storage: str | None=typer.Option(None, '--storage', help='Storage backend: forsy-r2 or github.'),
+):
+    if not full and mode not in {None, "full"}:
+        raise typer.BadParameter("Only Full Experience Compilation export is supported for this command.")
+    try:
+        package = _package_for_ecosystem_item(item_id, registry=registry, storage=storage)
+        exported = _copy_or_zip_package(package, output, item_id=item_id, source="ecosystem_export")
+    except Exception as exc:
+        typer.echo(f"Could not export Full Experience Compilation: {redact_secrets(str(exc))}")
+        raise typer.Exit(1)
+    typer.echo("Export Full Experience Compilation complete.")
+    typer.echo(f"item_id: {item_id}")
+    typer.echo(f"output: {exported}")
 
 
 def _summarize_bundle_manifest(manifest: dict) -> str:
@@ -2985,14 +3710,16 @@ def _summarize_bundle_manifest(manifest: dict) -> str:
         'bundle_id','title','attempts','traced_steps','process_supervision_rows',
         'reward_modeling_rows','revision_preference_pairs','domains','subdomains',
         'agent_apprentice_role','expected_economic_value',
-        'expected_economic_value_for_agent_apprentice','mentor_mode','task_status','run_status'
+        'expected_economic_value_for_agent_apprentice','task_status','run_status'
     ]
     lines = []
     for key in keys:
         if key not in manifest:
             continue
-        value = mentor_mode_display(manifest.get(key)) if key == "mentor_mode" else manifest.get(key)
-        lines.append(f"{key}: {value}")
+        lines.append(f"{key}: {manifest.get(key)}")
+    mode = manifest.get("apprenticeship_mode") or manifest.get("mentor_mode")
+    if mode:
+        lines.append(f"apprenticeship_mode: {apprenticeship_mode_display(normalize_apprenticeship_mode(str(mode)))}")
     return "\n".join(lines)
 
 
@@ -3017,21 +3744,23 @@ def _summarize_seed_registry_row(row: dict) -> str:
         lines.append(f"domains: {row.get('domains')}")
     if row.get("subdomains"):
         lines.append(f"subdomains: {row.get('subdomains')}")
-    lines.append("note: this is a seed task, not a completed Contribution Bundle")
+    lines.append("note: this is a seed task, not a completed Experience Compilation")
     return "\n".join(lines)
 
 
 def _summarize_contribution_registry_row(row: dict) -> str:
+    item_id = _row_id(row)
+    compiler = row.get("experience_compiler") or {}
+    available = row.get("available_outputs") or {}
     lines = [
-        "kind: contribution_bundle",
-        f"bundle_id: {row.get('bundle_id')}",
+        f"kind: {row.get('kind') or 'agent_experience_package'}",
+        f"item_id: {item_id}",
         f"title: {row.get('title')}",
         f"task_status: {row.get('task_status') or 'unknown'}",
         f"run_status: {row.get('run_status') or 'unknown'}",
     ]
     for key in [
         "apprentice_agent",
-        "mentor_mode",
         "mentor_model_provider",
         "attempts",
         "traced_steps",
@@ -3043,26 +3772,119 @@ def _summarize_contribution_registry_row(row: dict) -> str:
         "expected_economic_value_for_agent_apprentice",
     ]:
         if row.get(key) is not None:
-            value = mentor_mode_display(row.get(key)) if key == "mentor_mode" else row.get(key)
-            lines.append(f"{key}: {value}")
+            lines.append(f"{key}: {row.get(key)}")
+    mode = row.get("apprenticeship_mode") or row.get("mentor_mode")
+    if mode:
+        lines.append(f"apprenticeship_mode: {apprenticeship_mode_display(normalize_apprenticeship_mode(str(mode)))}")
     if row.get("domains"):
         lines.append(f"domains: {row.get('domains')}")
     if row.get("subdomains"):
         lines.append(f"subdomains: {row.get('subdomains')}")
+    lines.extend(
+        [
+            f"has Full Experience Compilation: {'yes' if available.get('full_experience_compilation', available.get('full_training_package', row.get('kind') == 'agent_experience_package')) else 'no'}",
+            f"has runtime training: {'yes' if available.get('runtime_training', row.get('kind') == 'agent_experience_package') else 'no'}",
+            f"skill title: {compiler.get('skill_title') or row.get('title') or 'unknown'}",
+            f"skill summary: {compiler.get('skill_summary') or compiler.get('runtime_training_summary') or 'available when Experience Compiler outputs are present'}",
+            f"environment domain: {compiler.get('environment_domain') or row.get('environment_domain') or row.get('domain') or 'unknown'}",
+            f"Experience Compiler status: {compiler.get('status') or row.get('experience_compiler_status') or row.get('tdo_status') or 'unknown'}",
+        ]
+    )
+    installed = [
+        skill for skill in list_installed_skills(get_settings())
+        if item_id in {str(skill.get("source_item_id") or ""), str(skill.get("source_package_id") or "")}
+    ]
+    lines.append(f"local installed status: {'installed' if installed else 'not installed'}")
+    lines.extend(
+        [
+            "",
+            "Available actions:",
+            "",
+            "1. Export Full Experience Compilation",
+            "   Use this when you want the complete traces, artifacts, training data, evaluation data, runtime learning, and generated data packages for research/training/evaluation pipelines.",
+            "   Command:",
+            f"   apprentice ecosystem export {item_id} --full --output <path>",
+            "",
+            "2. Install Runtime Training",
+            "   Use this when you want your Apprentice Agent to use the compiled skill/runtime learning in future runs.",
+            "   Command:",
+            f"   apprentice learn install {item_id}",
+        ]
+    )
     return "\n".join(lines)
 
 
+def _local_package_registry_row(path: Path) -> dict:
+    package = _locate_package_root(path)
+    manifest = {}
+    for candidate in [
+        package / "contribution_manifest.json",
+        package / "task_manifest.json",
+        package / "package_manifest.json",
+        package / "manifest.json",
+    ]:
+        if candidate.exists():
+            try:
+                manifest = read_json(candidate)
+                break
+            except Exception:
+                manifest = {}
+    compiler = package / "experience_compiler"
+    canonical = compiler / "skill_pack" / "canonical_skill.json"
+    skill = read_json(canonical) if canonical.exists() else {}
+    compiler_report = read_json(compiler / "compiler_report.json") if (compiler / "compiler_report.json").exists() else {}
+    item_id = str(manifest.get("item_id") or manifest.get("package_id") or package.name)
+    return {
+        "id": item_id,
+        "kind": "agent_experience_package",
+        "title": skill.get("title") or manifest.get("title") or package.name,
+        "summary": skill.get("summary") or compiler_report.get("description"),
+        "domain": manifest.get("domain"),
+        "subdomain": manifest.get("subdomain"),
+        "package_id": manifest.get("package_id") or item_id,
+        "task_id": manifest.get("task_id"),
+        "local_bundle_path": str(package),
+        "experience_compiler_status": compiler_report.get("compiler_status") or compiler_report.get("tdo_status") or ("completed" if compiler.exists() else "unknown"),
+        "available_outputs": {
+            "full_experience_compilation": True,
+            "full_training_package": True,
+            "runtime_training": bool((compiler / "skill_pack" / "skill.md").exists()),
+            "skill_pack": (compiler / "skill_pack").exists(),
+            "training_time_package": (compiler / "training_time_package").exists(),
+            "eval_package": (compiler / "eval_package").exists(),
+            "environment_package": (compiler / "environment").exists(),
+        },
+        "experience_compiler": {
+            "enabled": compiler.exists(),
+            "status": compiler_report.get("compiler_status") or compiler_report.get("tdo_status") or ("completed" if compiler.exists() else "unknown"),
+            "skill_title": skill.get("title") or manifest.get("title") or package.name,
+            "skill_summary": skill.get("summary") or compiler_report.get("description"),
+            "runtime_training_summary": skill.get("summary") or "Runtime training available from local Experience Compiler outputs.",
+            "training_data_counts": compiler_report.get("rows_accepted_by_type") or {},
+            "environment_domain": manifest.get("environment_domain") or manifest.get("domain"),
+        },
+    }
+
+
 @ecosystem_app.command('inspect')
 def ecosystem_inspect(
     bundle_id: str=typer.Argument(...),
     registry: Path | None=typer.Option(None, '--registry', help='Public ecosystem index JSON path for offline/test use.'),
+    storage: str | None=typer.Option(None, '--storage', help='Storage backend: forsy-r2 or github.'),
 ):
+    local_arg = Path(bundle_id).expanduser()
+    if local_arg.exists():
+        typer.echo(_summarize_contribution_registry_row(_local_package_registry_row(local_arg)))
+        return
     bundle_path=get_settings().app_home / 'ecosystem' / 'bundles' / bundle_id
     if bundle_path.exists() and (bundle_path/'contribution_manifest.json').exists():
         typer.echo(_summarize_bundle_manifest(read_json(bundle_path/'contribution_manifest.json')))
         return
     try:
-        row=_find_registry_row(bundle_id, registry)
+        if normalize_ecosystem_storage(storage or get_settings().ecosystem_storage_backend) == "forsy-r2" and registry is None:
+            row=fetch_r2_item(bundle_id, get_settings())
+        else:
+            row=_find_registry_row(bundle_id, registry, storage=storage)
     except FileNotFoundError as exc:
         typer.echo(str(exc))
         raise typer.Exit(1)
@@ -3073,10 +3895,12 @@ def ecosystem_inspect(
 
 
 @bundle_app.command('inspect')
-def bundle_inspect(path: Path=typer.Argument(..., help='Contribution Bundle folder.')):
+def bundle_inspect(path: Path=typer.Argument(..., help='Experience Compilation folder.')):
+    from .loop_review import summarize_loop_reviews
+
     manifest=path/'contribution_manifest.json'
     if not manifest.exists():
-        typer.echo(f'Contribution Bundle manifest not found: {manifest}')
+        typer.echo(f'Experience Compilation manifest not found: {manifest}')
         raise typer.Exit(1)
     manifest_data=read_json(manifest)
     artifacts=_artifact_index(path)
@@ -3092,6 +3916,15 @@ def bundle_inspect(path: Path=typer.Argument(..., help='Contribution Bundle fold
     typer.echo(f"follow_up_count: {len(followups)}")
     if checkpoints:
         typer.echo(f"mentor_checkpoint_count: {len(checkpoints)}")
+    loop_summary = summarize_loop_reviews(path)
+    if loop_summary.get("has_loop_review_packets"):
+        typer.echo(f"loop_review_packets: {loop_summary.get('loop_iteration_count')}")
+        typer.echo(f"loop_final_verdict: {loop_summary.get('final_loop_verdict') or 'unknown'}")
+        reviewers = ", ".join(loop_summary.get("reviewer_types") or []) or "unknown"
+        typer.echo(f"loop_reviewer_types: {reviewers}")
+        refs = loop_summary.get("loop_review_refs") or []
+        if refs:
+            typer.echo(f"latest_review_packet: {refs[-1]}")
     top=[row.get("package_relative_path") or row.get("artifact_ref") for row in artifacts[:5]]
     if top:
         typer.echo("top_artifacts:")
@@ -3102,14 +3935,16 @@ def bundle_inspect(path: Path=typer.Argument(..., help='Contribution Bundle fold
 
 
 @bundle_app.command('check')
-def bundle_check(path: Path=typer.Argument(..., help='Contribution Bundle folder.')):
+def bundle_check(path: Path=typer.Argument(..., help='Experience Compilation folder.')):
+    from .artifact_resolver import artifact_ref_candidates, artifact_ref_resolves, normalize_artifact_ref
+
     issues: list[str] = []
     bundle = Path(path).expanduser()
     manifest_path = bundle / "contribution_manifest.json"
     if not bundle.exists():
         issues.append(f"Bundle path does not exist: {bundle}")
     elif not manifest_path.exists():
-        issues.append(f"Contribution Bundle manifest not found: {manifest_path}")
+        issues.append(f"Experience Compilation manifest not found: {manifest_path}")
     manifest_data = {}
     if manifest_path.exists():
         try:
@@ -3129,8 +3964,16 @@ def bundle_check(path: Path=typer.Argument(..., help='Contribution Bundle folder
             issues.append(f"outputs/artifacts_index.json could not be parsed: {exc}")
     for row in artifacts:
         ref = row.get("package_relative_path") or row.get("artifact_ref")
-        if ref and not (bundle / str(ref)).exists():
-            issues.append(f"Referenced artifact is missing: {ref}")
+        if ref:
+            normalized = normalize_artifact_ref(ref)
+            existing_refs = {
+                str(p.relative_to(bundle)).replace("\\", "/")
+                for p in bundle.rglob("*")
+                if p.is_file()
+            }
+            candidates = artifact_ref_candidates(normalized) | {normalized}
+            if not any((bundle / candidate).exists() for candidate in candidates) and not artifact_ref_resolves(normalized, existing_refs):
+                issues.append(f"Referenced artifact is missing: {ref}")
     for optional in ["session_events.jsonl", "progress_events.jsonl"]:
         file_path = bundle / optional
         if file_path.exists():
@@ -3138,39 +3981,105 @@ def bundle_check(path: Path=typer.Argument(..., help='Contribution Bundle folder
                 read_jsonl(file_path)
             except Exception as exc:
                 issues.append(f"{optional} could not be parsed: {exc}")
+    for ref in manifest_data.get("experience_compiler_output_refs") or []:
+        normalized = normalize_artifact_ref(ref)
+        if not (bundle / normalized).exists():
+            issues.append(f"Referenced Experience Compiler output is missing: {ref}")
+    for ref in manifest_data.get("tdo_output_refs") or []:
+        normalized = normalize_artifact_ref(ref)
+        if not (bundle / normalized).exists():
+            issues.append(f"Referenced legacy learning output is missing: {ref}")
+    for ref in manifest_data.get("loop_review_refs") or []:
+        normalized = normalize_artifact_ref(ref)
+        if not (bundle / normalized).exists():
+            issues.append(f"Referenced loop review packet is missing: {ref}")
+    tdo_dir = bundle / "tdo"
+    if tdo_dir.exists():
+        for file_path in tdo_dir.rglob("*.json"):
+            try:
+                read_json(file_path)
+            except Exception as exc:
+                issues.append(f"{file_path.relative_to(bundle)} could not be parsed: {exc}")
+        for file_path in tdo_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}")
+    compiler_dir = bundle / "experience_compiler"
+    if compiler_dir.exists():
+        for file_path in compiler_dir.rglob("*.json"):
+            try:
+                read_json(file_path)
+            except Exception as exc:
+                issues.append(f"{file_path.relative_to(bundle)} could not be parsed: {exc}")
+    loops_dir = bundle / "loops"
+    if loops_dir.exists():
+        for file_path in loops_dir.rglob("*.json"):
+            try:
+                read_json(file_path)
+            except Exception as exc:
+                issues.append(f"{file_path.relative_to(bundle)} could not be parsed: {exc}")
+        for file_path in loops_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}")
+        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():
+            continue
+        try:
+            for trace in read_jsonl(trace_path):
+                for step in trace.get("steps") or []:
+                    missing = step.get("missing_surface_fields") or []
+                    status = step.get("surface_capture_status")
+                    surface = step.get("interaction_surface")
+                    if surface and status in {"partial", "unavailable"} and missing:
+                        surface_warnings.append(
+                            f"{trace_path.relative_to(bundle)} step {step.get('step')}: {surface} capture {status}; missing {', '.join(str(x) for x in missing[:6])}"
+                        )
+        except Exception:
+            pass
     secret_hits = _bundle_secret_hits(bundle) if bundle.exists() else []
     if secret_hits:
         issues.append("Obvious secret-like values were found: " + ", ".join(secret_hits[:10]))
     if issues:
-        typer.echo("Bundle check: needs attention")
-        typer.echo(f"Bundle: {bundle}")
+        typer.echo("Experience Compilation check: needs attention")
+        typer.echo(f"Experience Compilation: {bundle}")
         for issue in issues:
             typer.echo(f"Reason: {redact_secrets(issue)}")
         typer.echo("Next action: fix the packaging issue, then rerun `apprentice bundle check`.")
         raise typer.Exit(1)
     status = manifest_data.get("task_status") or manifest_data.get("run_status") or "unknown"
-    typer.echo("Bundle check: passed")
-    typer.echo(f"Bundle: {bundle}")
+    typer.echo("Experience Compilation check: passed")
+    typer.echo(f"Experience Compilation: {bundle}")
     typer.echo(f"Task status: {status}")
-    typer.echo("This bundle is ready to add to the public ecosystem.")
+    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.")
 
 
 @bundle_app.command('contribute')
-def bundle_contribute(path: Path=typer.Argument(..., help='Contribution Bundle folder.')):
+def bundle_contribute(path: Path=typer.Argument(..., help='Experience Compilation folder.')):
     manifest=path/'contribution_manifest.json'
     if not manifest.exists():
-        typer.echo(f'Contribution Bundle manifest not found: {manifest}')
+        typer.echo(f'Experience Compilation manifest not found: {manifest}')
         raise typer.Exit(1)
     try:
         submission_dir, package_zip, metadata = _create_ecosystem_submission(path)
     except Exception as exc:
         typer.echo(f"Could not prepare public ecosystem contribution: {redact_secrets(str(exc))}")
         raise typer.Exit(1)
-    typer.echo('Contribution Bundle ready.')
+    typer.echo('Experience Compilation ready.')
     typer.echo('')
     typer.echo(f"Bundle ID: {metadata.get('bundle_id')}")
     typer.echo(f"Title: {metadata.get('title')}")
-    typer.echo('Bundle:')
+    typer.echo('Experience Compilation:')
     typer.echo(str(path))
     typer.echo('')
     typer.echo('No upload was performed by this command.')