agent-apprenticeship 0.1.5 → 0.1.7

package/src/agent_apprenticeship_trace/config.py

@@ -16,23 +16,93 @@ from .io import read_json, write_json
 from .recipes import MODEL_PROVIDER_RECIPES, WORKER_AGENT_RECIPES
 
 
+ApprenticeshipMode = Literal["autonomous", "expert_led", "org_custom"]
 MentorMode = Literal["model_assisted", "expert_led", "hybrid"]
 SensitiveInfoMasking = Literal["standard", "no_masking"]
-EcosystemAutoShare = Literal["manual", "ask", "automatic"]
+EcosystemAutoShare = Literal["manual", "automatic", "disabled"]
+TrainingContributionMode = Literal["public_ecosystem", "private_internal_only"]
+EcosystemStorageBackend = Literal["forsy-r2", "github"]
 EvaluationMode = Literal["model-assisted", "expert-led", "hybrid"]
 DataSharingLevel = Literal["standard", "full-context"]
 
+APPRENTICESHIP_MODES: tuple[str, ...] = ("autonomous", "expert_led", "org_custom")
 MENTOR_MODES: tuple[str, ...] = ("model_assisted", "expert_led", "hybrid")
 SENSITIVE_INFO_MASKING_LEVELS: tuple[str, ...] = ("standard", "no_masking")
-ECOSYSTEM_AUTO_SHARE_MODES: tuple[str, ...] = ("manual", "ask", "automatic")
+ECOSYSTEM_AUTO_SHARE_MODES: tuple[str, ...] = ("manual", "automatic", "disabled")
+TRAINING_CONTRIBUTION_MODES: tuple[str, ...] = ("public_ecosystem", "private_internal_only")
 EVALUATION_MODES: tuple[str, ...] = ("model-assisted", "expert-led", "hybrid")
 DATA_SHARING_LEVELS: tuple[str, ...] = ("standard", "full-context")
 DEFAULT_APP_HOME = Path("~/.agent-apprenticeship").expanduser()
 DEFAULT_PUBLIC_ECOSYSTEM_REPO = "Forsy-AI/agent-apprenticeship"
 DEFAULT_PUBLIC_ECOSYSTEM_URL = f"https://github.com/{DEFAULT_PUBLIC_ECOSYSTEM_REPO}"
+DEFAULT_ECOSYSTEM_STORAGE_BACKEND = "forsy-r2"
+DEFAULT_R2_BUCKET = "apprenticeship-dev"
+DEFAULT_R2_INDEX_PREFIX = "indexes"
+DEFAULT_R2_CONTRIBUTION_PREFIX = "contributions/packages"
+DEFAULT_R2_SEED_PREFIX = "contributions/seed_dataset"
+DEFAULT_R2_API_BASE = "https://agent-apprenticeship-ingest.sai-1c1.workers.dev"
 _SETTINGS_OVERRIDE: ContextVar[Any] = ContextVar("agent_apprenticeship_settings_override", default=None)
 
 
+def normalize_apprenticeship_mode(value: str | None, default: str = "autonomous") -> str:
+    if value is None or str(value).strip() == "":
+        return default
+    normalized = str(value).strip().lower().replace("-", "_").replace(" ", "_")
+    aliases = {
+        "autonomous": "autonomous",
+        "autonomous_apprenticeship": "autonomous",
+        "model": "autonomous",
+        "model_assisted": "autonomous",
+        "model_assisted_automated": "autonomous",
+        "modelassisted": "autonomous",
+        "automated": "autonomous",
+        "expert": "expert_led",
+        "expert_led": "expert_led",
+        "expert_led_apprenticeship": "expert_led",
+        "expert_led_manual": "expert_led",
+        "manual": "expert_led",
+        "human": "expert_led",
+        "hybrid": "expert_led",
+        "org": "org_custom",
+        "organization": "org_custom",
+        "organization_custom": "org_custom",
+        "org_custom": "org_custom",
+        "custom_org": "org_custom",
+        "custom": "org_custom",
+    }
+    normalized = aliases.get(normalized, normalized)
+    if normalized not in APPRENTICESHIP_MODES:
+        raise ValueError(f"Unsupported Apprenticeship Mode: {value}")
+    return normalized
+
+
+def apprenticeship_mode_display(value: str | None) -> str:
+    normalized = normalize_apprenticeship_mode(value)
+    return {
+        "autonomous": "Autonomous Apprenticeship",
+        "expert_led": "Expert-Led Apprenticeship",
+        "org_custom": "Organization Custom",
+    }[normalized]
+
+
+def apprenticeship_mode_to_mentor_mode(value: str | None) -> str:
+    normalized = normalize_apprenticeship_mode(value)
+    return {
+        "autonomous": "model_assisted",
+        "expert_led": "expert_led",
+        "org_custom": "expert_led",
+    }[normalized]
+
+
+def mentor_mode_to_apprenticeship_mode(value: str | None) -> str:
+    normalized = normalize_mentor_mode(value)
+    return {
+        "model_assisted": "autonomous",
+        "expert_led": "expert_led",
+        "hybrid": "expert_led",
+    }[normalized]
+
+
 def normalize_mentor_mode(value: str | None, default: str = "model_assisted") -> str:
     if value is None or str(value).strip() == "":
         return default
@@ -50,7 +120,7 @@ def normalize_mentor_mode(value: str | None, default: str = "model_assisted") ->
     }
     normalized = aliases.get(normalized, normalized)
     if normalized not in MENTOR_MODES:
-        raise ValueError(f"Unsupported Mentor Mode: {value}")
+        raise ValueError(f"Unsupported apprenticeship mode: {value}")
     return normalized
 
 
@@ -68,12 +138,7 @@ def evaluation_mode_to_mentor_mode(value: str | None) -> str:
 
 
 def mentor_mode_display(value: str | None) -> str:
-    normalized = normalize_mentor_mode(value)
-    return {
-        "model_assisted": "model-assisted",
-        "expert_led": "expert-led",
-        "hybrid": "hybrid",
-    }[normalized]
+    return apprenticeship_mode_display(mentor_mode_to_apprenticeship_mode(value))
 
 
 def normalize_sensitive_info_masking(value: str | None, default: str = "standard") -> str:
@@ -110,31 +175,100 @@ def normalize_ecosystem_auto_share(value: str | None, default: str = "manual") -
     normalized = str(value).strip().lower().replace("-", "_").replace(" ", "_")
     aliases = {
         "manual": "manual",
-        "off": "manual",
-        "none": "manual",
-        "ask": "ask",
-        "prompt": "ask",
-        "ask_before_sharing": "ask",
+        "ask": "manual",
+        "prompt": "manual",
+        "ask_before_sharing": "manual",
         "share_automatically": "automatic",
         "automatic": "automatic",
         "auto": "automatic",
         "on": "automatic",
+        "disabled": "disabled",
+        "disable": "disabled",
+        "off": "disabled",
+        "none": "disabled",
     }
     normalized = aliases.get(normalized, normalized)
     if normalized not in ECOSYSTEM_AUTO_SHARE_MODES:
-        raise ValueError(f"Unsupported Ecosystem Auto-Share setting: {value}")
+        raise ValueError(f"Unsupported ecosystem sharing setting: {value}")
     return normalized
 
 
 def ecosystem_auto_share_display(value: str | None) -> str:
     normalized = normalize_ecosystem_auto_share(value)
     return {
-        "manual": "Manual",
-        "ask": "Ask before sharing",
-        "automatic": "Share automatically",
+        "manual": "manual",
+        "automatic": "automatic",
+        "disabled": "disabled",
     }[normalized]
 
 
+def normalize_training_contribution_mode(value: str | None, default: str = "public_ecosystem") -> str:
+    if value is None or str(value).strip() == "":
+        return default
+    normalized = str(value).strip().lower().replace("-", "_").replace(" ", "_")
+    aliases = {
+        "public": "public_ecosystem",
+        "public_ecosystem": "public_ecosystem",
+        "public_ecosystem_default": "public_ecosystem",
+        "ecosystem": "public_ecosystem",
+        "share": "public_ecosystem",
+        "shared": "public_ecosystem",
+        "automatic": "public_ecosystem",
+        "auto": "public_ecosystem",
+        "on": "public_ecosystem",
+        "private": "private_internal_only",
+        "private_internal": "private_internal_only",
+        "private_internal_only": "private_internal_only",
+        "internal": "private_internal_only",
+        "local": "private_internal_only",
+        "manual": "private_internal_only",
+        "ask": "private_internal_only",
+        "disabled": "private_internal_only",
+        "disable": "private_internal_only",
+        "off": "private_internal_only",
+        "none": "private_internal_only",
+    }
+    normalized = aliases.get(normalized, normalized)
+    if normalized not in TRAINING_CONTRIBUTION_MODES:
+        raise ValueError(f"Unsupported Agent Training Contribution Mode: {value}")
+    return normalized
+
+
+def training_contribution_mode_display(value: str | None) -> str:
+    normalized = normalize_training_contribution_mode(value)
+    return {
+        "public_ecosystem": "Public Ecosystem",
+        "private_internal_only": "Private Internal Only",
+    }[normalized]
+
+
+def training_contribution_to_auto_share(value: str | None) -> str:
+    return "automatic" if normalize_training_contribution_mode(value) == "public_ecosystem" else "disabled"
+
+
+def auto_share_to_training_contribution(value: str | None) -> str:
+    return "private_internal_only" if normalize_ecosystem_auto_share(value) == "disabled" else "public_ecosystem"
+
+
+def normalize_ecosystem_storage(value: str | None, default: str = DEFAULT_ECOSYSTEM_STORAGE_BACKEND) -> str:
+    if value is None or str(value).strip() == "":
+        return default
+    normalized = str(value).strip().lower().replace("_", "-")
+    aliases = {
+        "r2": "forsy-r2",
+        "cloudflare-r2": "forsy-r2",
+        "cloudflare_r2": "forsy-r2",
+        "forsy-r2": "forsy-r2",
+        "github": "github",
+        "github-issue": "github",
+        "legacy-github": "github",
+    }
+    normalized = aliases.get(normalized, normalized)
+    if normalized not in {"forsy-r2", "github"}:
+        raise ValueError(f"Unsupported ecosystem storage backend: {value}")
+    return normalized
+
+
 class Settings(BaseModel):
     # Public product settings.
     app_home: Path = DEFAULT_APP_HOME
@@ -145,6 +279,7 @@ class Settings(BaseModel):
     model_provider: str | None = None
     model_provider_api_key_env: str | None = None
     model_provider_model: str | None = None
+    apprenticeship_mode: ApprenticeshipMode = "autonomous"
     mentor_mode: MentorMode = "model_assisted"
     sensitive_info_masking: SensitiveInfoMasking = "standard"
     evaluation_mode: EvaluationMode = "model-assisted"
@@ -159,7 +294,14 @@ class Settings(BaseModel):
     mentor_model_provider_readiness_reason: str | None = None
     ecosystem_repo: str | None = DEFAULT_PUBLIC_ECOSYSTEM_REPO
     ecosystem_repo_path: Path | None = None
-    ecosystem_auto_share: EcosystemAutoShare = "manual"
+    training_contribution_mode: TrainingContributionMode = "public_ecosystem"
+    ecosystem_auto_share: EcosystemAutoShare = "automatic"
+    ecosystem_storage_backend: EcosystemStorageBackend = DEFAULT_ECOSYSTEM_STORAGE_BACKEND
+    r2_api_url: str | None = DEFAULT_R2_API_BASE
+    r2_bucket: str = DEFAULT_R2_BUCKET
+    r2_index_prefix: str = DEFAULT_R2_INDEX_PREFIX
+    r2_contribution_prefix: str = DEFAULT_R2_CONTRIBUTION_PREFIX
+    r2_seed_prefix: str = DEFAULT_R2_SEED_PREFIX
 
     # Compatibility settings used by the existing internal pipeline.
     openai_api_key: str | None = None
@@ -264,13 +406,19 @@ def get_settings(root: Path | None = None) -> Settings:
     )
     legacy_iterations = _int_env("AA_MAX_ITERATIONS", int(stored.get("max_iterations") or 3))
     openai_model = os.getenv("AA_OPENAI_MODEL", stored.get("openai_model") or "gpt-5-mini")
-    mentor_mode = normalize_mentor_mode(
+    new_mode_source = os.getenv("AA_APPRENTICESHIP_MODE") or stored.get("apprenticeship_mode")
+    legacy_mode_source = (
         os.getenv("AA_MENTOR_MODE")
         or stored.get("mentor_mode")
         or os.getenv("AA_EVALUATION_MODE")
         or stored.get("evaluation_mode")
-        or "model_assisted"
     )
+    apprenticeship_mode = normalize_apprenticeship_mode(new_mode_source or legacy_mode_source or "autonomous")
+    mentor_mode = apprenticeship_mode_to_mentor_mode(apprenticeship_mode)
+    if not new_mode_source and legacy_mode_source:
+        legacy_mentor_mode = normalize_mentor_mode(legacy_mode_source)
+        if legacy_mentor_mode == "hybrid":
+            mentor_mode = "hybrid"
     sensitive_info_masking = normalize_sensitive_info_masking(
         os.getenv("AA_SENSITIVE_INFO_MASKING")
         or stored.get("sensitive_info_masking")
@@ -278,6 +426,18 @@ def get_settings(root: Path | None = None) -> Settings:
         or stored.get("data_sharing_level")
         or "standard"
     )
+    auto_share_source = os.getenv("AA_ECOSYSTEM_AUTO_SHARE") or stored.get("ecosystem_auto_share")
+    training_contribution_source = os.getenv("AA_TRAINING_CONTRIBUTION_MODE") or stored.get("training_contribution_mode")
+    if training_contribution_source:
+        training_contribution_mode = normalize_training_contribution_mode(training_contribution_source)
+    elif auto_share_source:
+        training_contribution_mode = auto_share_to_training_contribution(auto_share_source)
+    else:
+        training_contribution_mode = "public_ecosystem"
+    if auto_share_source:
+        ecosystem_auto_share = normalize_ecosystem_auto_share(auto_share_source)
+    else:
+        ecosystem_auto_share = training_contribution_to_auto_share(training_contribution_mode)
 
     return Settings(
         app_home=home,
@@ -288,6 +448,7 @@ def get_settings(root: Path | None = None) -> Settings:
         model_provider=provider,
         model_provider_api_key_env=provider_key_env,
         model_provider_model=provider_model,
+        apprenticeship_mode=apprenticeship_mode,
         mentor_mode=mentor_mode,
         sensitive_info_masking=sensitive_info_masking,
         evaluation_mode=mentor_mode_to_evaluation_mode(mentor_mode),
@@ -304,9 +465,24 @@ def get_settings(root: Path | None = None) -> Settings:
         ecosystem_repo_path=Path(os.getenv("AA_ECOSYSTEM_REPO_PATH") or stored.get("ecosystem_repo_path")).expanduser()
         if (os.getenv("AA_ECOSYSTEM_REPO_PATH") or stored.get("ecosystem_repo_path"))
         else None,
-        ecosystem_auto_share=normalize_ecosystem_auto_share(
-            os.getenv("AA_ECOSYSTEM_AUTO_SHARE") or stored.get("ecosystem_auto_share") or "manual"
+        training_contribution_mode=training_contribution_mode,
+        ecosystem_auto_share=ecosystem_auto_share,
+        ecosystem_storage_backend=normalize_ecosystem_storage(
+            os.getenv("AA_R2_STORAGE_BACKEND")
+            or os.getenv("AA_ECOSYSTEM_STORAGE_BACKEND")
+            or stored.get("ecosystem_storage_backend")
+            or DEFAULT_ECOSYSTEM_STORAGE_BACKEND
+        ),
+        r2_api_url=(
+            os.getenv("AA_R2_API_BASE")
+            or os.getenv("AA_R2_API_URL")
+            or stored.get("r2_api_url")
+            or DEFAULT_R2_API_BASE
         ),
+        r2_bucket=os.getenv("AA_R2_BUCKET") or stored.get("r2_bucket") or DEFAULT_R2_BUCKET,
+        r2_index_prefix=os.getenv("AA_R2_INDEX_PREFIX") or stored.get("r2_index_prefix") or DEFAULT_R2_INDEX_PREFIX,
+        r2_contribution_prefix=os.getenv("AA_R2_CONTRIBUTION_PREFIX") or stored.get("r2_contribution_prefix") or DEFAULT_R2_CONTRIBUTION_PREFIX,
+        r2_seed_prefix=os.getenv("AA_R2_SEED_PREFIX") or stored.get("r2_seed_prefix") or DEFAULT_R2_SEED_PREFIX,
         openai_api_key=os.getenv("OPENAI_API_KEY"),
         openai_model=openai_model,
         worker_runner=os.getenv("AA_WORKER_RUNNER", os.getenv("AA_TRACE_WORKER_RUNNER", stored.get("worker_runner") or worker_agent)),
@@ -355,18 +531,45 @@ def update_settings(**updates: Any) -> Settings:
     settings = get_settings()
     data = settings.model_dump()
     clean_updates = {k: v for k, v in updates.items() if v is not None}
+    legacy_requested_mode = None
+    if "apprenticeship_mode" not in clean_updates:
+        if "mentor_mode" in clean_updates:
+            legacy_requested_mode = clean_updates["mentor_mode"]
+        elif "evaluation_mode" in clean_updates:
+            legacy_requested_mode = evaluation_mode_to_mentor_mode(clean_updates["evaluation_mode"])
+    if "mentor_mode" in clean_updates and "apprenticeship_mode" not in clean_updates:
+        clean_updates["apprenticeship_mode"] = mentor_mode_to_apprenticeship_mode(clean_updates["mentor_mode"])
     if "evaluation_mode" in clean_updates and "mentor_mode" not in clean_updates:
-        clean_updates["mentor_mode"] = evaluation_mode_to_mentor_mode(clean_updates["evaluation_mode"])
+        clean_updates["apprenticeship_mode"] = mentor_mode_to_apprenticeship_mode(
+            evaluation_mode_to_mentor_mode(clean_updates["evaluation_mode"])
+        )
+    if "apprenticeship_mode" in clean_updates:
+        clean_updates["apprenticeship_mode"] = normalize_apprenticeship_mode(clean_updates["apprenticeship_mode"])
+        clean_updates["mentor_mode"] = apprenticeship_mode_to_mentor_mode(clean_updates["apprenticeship_mode"])
+        clean_updates["evaluation_mode"] = mentor_mode_to_evaluation_mode(clean_updates["mentor_mode"])
     if "mentor_mode" in clean_updates:
         clean_updates["mentor_mode"] = normalize_mentor_mode(clean_updates["mentor_mode"])
+        clean_updates["apprenticeship_mode"] = mentor_mode_to_apprenticeship_mode(clean_updates["mentor_mode"])
         clean_updates["evaluation_mode"] = mentor_mode_to_evaluation_mode(clean_updates["mentor_mode"])
+    if legacy_requested_mode and normalize_mentor_mode(legacy_requested_mode) == "hybrid":
+        clean_updates["apprenticeship_mode"] = "expert_led"
+        clean_updates["mentor_mode"] = "hybrid"
+        clean_updates["evaluation_mode"] = "hybrid"
     if "data_sharing_level" in clean_updates and "sensitive_info_masking" not in clean_updates:
         clean_updates["sensitive_info_masking"] = data_sharing_to_sensitive_info_masking(clean_updates["data_sharing_level"])
     if "sensitive_info_masking" in clean_updates:
         clean_updates["sensitive_info_masking"] = normalize_sensitive_info_masking(clean_updates["sensitive_info_masking"])
         clean_updates["data_sharing_level"] = sensitive_info_masking_to_data_sharing(clean_updates["sensitive_info_masking"])
+    if "ecosystem_auto_share" in clean_updates and "training_contribution_mode" not in clean_updates:
+        clean_updates["training_contribution_mode"] = auto_share_to_training_contribution(clean_updates["ecosystem_auto_share"])
+    if "training_contribution_mode" in clean_updates:
+        clean_updates["training_contribution_mode"] = normalize_training_contribution_mode(clean_updates["training_contribution_mode"])
+        if "ecosystem_auto_share" not in clean_updates:
+            clean_updates["ecosystem_auto_share"] = training_contribution_to_auto_share(clean_updates["training_contribution_mode"])
     if "ecosystem_auto_share" in clean_updates:
         clean_updates["ecosystem_auto_share"] = normalize_ecosystem_auto_share(clean_updates["ecosystem_auto_share"])
+    if "ecosystem_storage_backend" in clean_updates:
+        clean_updates["ecosystem_storage_backend"] = normalize_ecosystem_storage(clean_updates["ecosystem_storage_backend"])
     if "worker_agent" in clean_updates and "worker_runner" not in clean_updates:
         clean_updates["worker_runner"] = clean_updates["worker_agent"]
         clean_updates["reviser_runner"] = clean_updates["worker_agent"]
@@ -377,15 +580,19 @@ def update_settings(**updates: Any) -> Settings:
     if updated.model_provider is not None and updated.model_provider not in MODEL_PROVIDER_RECIPES:
         raise ValueError(f"Unsupported Mentor Model Provider: {updated.model_provider}")
     if updated.evaluation_mode not in EVALUATION_MODES:
-        raise ValueError(f"Unsupported Mentor Mode: {updated.mentor_mode}")
+        raise ValueError(f"Unsupported Apprenticeship Mode: {updated.apprenticeship_mode}")
     if updated.data_sharing_level not in DATA_SHARING_LEVELS:
         raise ValueError(f"Unsupported Sensitive Info Masking setting: {updated.sensitive_info_masking}")
     if updated.mentor_mode not in MENTOR_MODES:
         raise ValueError(f"Unsupported mentor mode: {updated.mentor_mode}")
+    if updated.apprenticeship_mode not in APPRENTICESHIP_MODES:
+        raise ValueError(f"Unsupported Apprenticeship Mode: {updated.apprenticeship_mode}")
     if updated.sensitive_info_masking not in SENSITIVE_INFO_MASKING_LEVELS:
         raise ValueError(f"Unsupported sensitive info masking setting: {updated.sensitive_info_masking}")
     if updated.ecosystem_auto_share not in ECOSYSTEM_AUTO_SHARE_MODES:
-        raise ValueError(f"Unsupported Ecosystem Auto-Share setting: {updated.ecosystem_auto_share}")
+        raise ValueError(f"Unsupported ecosystem sharing setting: {updated.ecosystem_auto_share}")
+    if updated.training_contribution_mode not in TRAINING_CONTRIBUTION_MODES:
+        raise ValueError(f"Unsupported Agent Training Contribution Mode: {updated.training_contribution_mode}")
     if updated.worker_agent == "custom":
         template = updated.custom_worker_command_template or ""
         missing = [token for token in ("{workspace}", "{prompt_file}") if token not in template]
@@ -575,12 +782,18 @@ def public_settings(settings: Settings | None = None) -> dict[str, Any]:
         "mentor_model_provider_status_reason": provider_status.get("reason"),
         "mentor_model_provider_api_key_env": provider_status.get("api_key_env_var"),
         "mentor_model_provider_api_key_visible": provider_status.get("api_key_visible"),
-        "mentor_mode": s.mentor_mode,
+        "apprenticeship_mode": s.apprenticeship_mode,
         "sensitive_info_masking": s.sensitive_info_masking,
         "max_improvement_loops": s.max_improvement_loops,
         "ecosystem_repo": s.ecosystem_repo,
         "ecosystem_repo_path": str(s.ecosystem_repo_path) if s.ecosystem_repo_path else None,
-        "ecosystem_auto_share": s.ecosystem_auto_share,
+        "training_contribution_mode": s.training_contribution_mode,
+        "ecosystem_storage_backend": s.ecosystem_storage_backend,
+        "r2_api_url": s.r2_api_url,
+        "r2_bucket": s.r2_bucket,
+        "r2_index_prefix": s.r2_index_prefix,
+        "r2_contribution_prefix": s.r2_contribution_prefix,
+        "r2_seed_prefix": s.r2_seed_prefix,
         "app_home": str(s.app_home),
     }
 
@@ -596,19 +809,25 @@ def public_settings_text(settings: Settings | None = None) -> str:
         _readiness_line("Apprentice Agent Status", data["apprentice_agent_status"], data.get("apprentice_agent_status_reason")),
         f"Mentor Model Provider: {provider}",
         _readiness_line("Mentor Model Provider Status", data["mentor_model_provider_status"], data.get("mentor_model_provider_status_reason")),
-        f"Mentor Mode: {mentor_mode_display(data['mentor_mode'])}",
+        f"Apprenticeship Mode: {apprenticeship_mode_display(data['apprenticeship_mode'])}",
         f"Sensitive Info Masking: {data['sensitive_info_masking']}",
         f"Maximum Improvement Loops: {data['max_improvement_loops']}",
         f"Public Ecosystem Repo: {data['ecosystem_repo'] or DEFAULT_PUBLIC_ECOSYSTEM_REPO}",
         *([f"Public Ecosystem Repo Path: {data['ecosystem_repo_path']}"] if data.get("ecosystem_repo_path") else []),
-        f"Ecosystem Auto-Share: {ecosystem_auto_share_display(data['ecosystem_auto_share'])}",
+        f"Storage backend: {data['ecosystem_storage_backend']}",
+        f"R2 ingestion API: {data['r2_api_url'] or 'not configured'}",
+        f"R2 bucket: {data['r2_bucket']}",
+        f"R2 index prefix: {data['r2_index_prefix']}",
+        f"R2 contribution prefix: {data['r2_contribution_prefix']}",
+        f"R2 seed prefix: {data['r2_seed_prefix']}",
+        f"Agent Training Contribution Mode: {training_contribution_mode_display(data['training_contribution_mode'])}",
         f"App Home: {data['app_home']}",
     ]
-    if s.mentor_mode in {"model_assisted", "hybrid"} and not configured_model_provider_ready(s):
+    if s.apprenticeship_mode == "autonomous" and not configured_model_provider_ready(s):
         lines.extend(
             [
                 "",
-                "Model-assisted Mentor Mode needs a ready Mentor Model Provider.",
+                "Autonomous Apprenticeship needs a ready Mentor Model Provider.",
                 "Run: apprentice configure model",
             ]
         )