agent-apprenticeship 0.1.6 → 0.1.8

package/src/agent_apprenticeship_trace/public_run.py

@@ -9,13 +9,108 @@ from pathlib import Path
 
 from .bundle_exporter import create_contribution_bundle
 from .config import Settings, apprentice_agent_display_name, apprentice_agent_readiness_status, get_settings, settings_override
+from .env import redact_secrets
 from .io import read_json, write_json
 from .loop import run_task
+from .loop_review import record_followup_review_update, record_human_loop_feedback
 from .mentor_checkpoints import write_mentor_checkpoints
 from .progress import ProgressCallback, append_progress_event, update_run_status
 from .recipes import WORKER_AGENT_RECIPES
 from .schemas import RawTaskRecord
 from .session_events import append_session_event, backfill_session_event_task_ids, next_followup_index
+from .tdo import run_tdo_for_run, utc_now
+
+
+def _write_failed_tdo_reports(run_root: Path, settings: Settings, error: str) -> None:
+    packages = sorted((run_root / "packages").glob("*")) if (run_root / "packages").exists() else []
+    for pkg in packages:
+        tdo_dir = pkg / "tdo"
+        tdo_dir.mkdir(parents=True, exist_ok=True)
+        safe_pkg = re.sub(r"[^A-Za-z0-9_]+", "_", pkg.name).strip("_") or "package"
+        report = {
+            "tdo_id": f"tdo_{safe_pkg}_failed",
+            "source_package_id": pkg.name,
+            "source_task_id": pkg.name,
+            "created_at": utc_now(),
+            "generator_mode": settings.worker_agent,
+            "tdo_judge_source": "apprentice_self_judge",
+            "mentor_audited": False,
+            "rounds_run": 0,
+            "stop_reason": "tdo_runtime_error",
+            "tdo_status": "failed",
+            "rows_generated_by_type": {},
+            "rows_accepted_by_type": {},
+            "rows_rejected_by_type": {},
+            "schema_validation_passed": False,
+            "sanitization_passed": False,
+            "weak_strong_proxy_available": False,
+            "grpo_suitability_distribution": {},
+            "omitted_outputs": ["experience_compiler_outputs"],
+            "generation_notes": [error],
+            "recommended_uses": [],
+            "metadata_json": {"failure_recorded_by": "runtime_guardrail"},
+        }
+        write_json(tdo_dir / "tdo_report.json", report)
+        write_json(tdo_dir / "tdo_manifest.json", {
+            "schema_version": "aa-tdo-v0.1",
+            "tdo_id": report["tdo_id"],
+            "tdo_status": "failed",
+            "source_package_id": pkg.name,
+            "source_task_id": pkg.name,
+            "tdo_output_refs": ["tdo/tdo_report.json", "tdo/tdo_manifest.json"],
+            "tdo_judge_source": "apprentice_self_judge",
+            "mentor_audited": False,
+            "rounds_run": 0,
+            "rows_by_type": {},
+            "created_at": report["created_at"],
+        })
+        compiler_dir = pkg / "experience_compiler"
+        compiler_dir.mkdir(parents=True, exist_ok=True)
+        write_json(compiler_dir / "compiler_report.json", {
+            "compiler_status": "failed",
+            "source_package_id": pkg.name,
+            "error": error,
+            "created_at": report["created_at"],
+        })
+        write_json(compiler_dir / "compiler_manifest.json", {
+            "schema_version": "aa-experience-compiler-v0.1",
+            "compiler_status": "failed",
+            "source_package_id": pkg.name,
+            "compiler_output_refs": ["experience_compiler/compiler_report.json", "experience_compiler/compiler_manifest.json"],
+            "created_at": report["created_at"],
+        })
+
+
+def _safe_run_tdo_for_run(
+    run_root: Path,
+    settings: Settings,
+    *,
+    progress_callback: ProgressCallback | None = None,
+    followup_index: int | None = None,
+    record_only: bool = False,
+) -> dict:
+    try:
+        return run_tdo_for_run(
+            run_root,
+            settings,
+            progress_callback=progress_callback,
+            followup_index=followup_index,
+            record_only=record_only,
+        )
+    except Exception as exc:
+        safe = redact_secrets(str(exc))[:500]
+        _write_failed_tdo_reports(run_root, settings, safe)
+        write_json(run_root / "tdo_status.json", {"tdo_status": "failed", "error": safe, "updated_at": utc_now()})
+        append_progress_event(
+            run_root,
+            "tdo_failed",
+            run_id=run_root.name,
+            message=f"Experience Compiler failed: {safe}",
+            phase="experience_compiler_failed",
+            metadata_json={"followup_index": followup_index} if followup_index else None,
+            callback=progress_callback,
+        )
+        return {"tdo_status": "failed", "error": safe}
 
 
 class RunInterrupted(Exception):
@@ -152,14 +247,14 @@ def _checkpoint_auto_approve(settings: Settings) -> bool:
 
 def _checkpoint_review_labels(settings: Settings, revision_requested: bool | None = None) -> tuple[str, str]:
     if settings.mentor_mode == "hybrid":
-        pending = "Hybrid model draft complete - human approval pending"
+        pending = "Expert-led model audit draft complete - human confirmation pending"
         if revision_requested is None:
-            return pending, "Hybrid human approval complete"
-        return pending, "Hybrid human approval complete - revision requested" if revision_requested else "Hybrid human approval complete - finish selected"
-    pending = "Expert review pending"
+            return pending, "Expert-led human confirmation complete"
+        return pending, "Expert-led human confirmation complete - revision requested" if revision_requested else "Expert-led human confirmation complete - finish selected"
+    pending = "Expert audit pending"
     if revision_requested is None:
-        return pending, "Expert review complete"
-    return pending, "Expert review complete - revision requested" if revision_requested else "Expert review complete - finish selected"
+        return pending, "Expert audit complete"
+    return pending, "Expert audit complete - revision requested" if revision_requested else "Expert audit complete - finish selected"
 
 
 def _pre_attempt_checkpoint_callback(
@@ -170,6 +265,17 @@ def _pre_attempt_checkpoint_callback(
     followup_index: int | None = None,
 ):
     def _callback(_pkg: Path) -> None:
+        append_progress_event(
+            run_root,
+            "apprentice_task_spec_ready",
+            run_id=run_root.name,
+            message=("Follow-up %s Apprentice Agent updated task-intake/rubric draft" % followup_index if followup_index else "Apprentice Agent drafted task intake and rubric"),
+            current_loop=1,
+            maximum_improvement_loops=settings.max_improvement_loops,
+            phase="task_intake_rubric",
+            metadata_json={"followup_index": followup_index, "draft_author": "apprentice_agent"} if followup_index else {"draft_author": "apprentice_agent"},
+            callback=progress_callback,
+        )
         if _human_checkpoint_mode(settings):
             write_mentor_checkpoints(
                 run_root,
@@ -227,34 +333,40 @@ def _revision_decision_callback(
     def _callback(pkg: Path) -> bool:
         status, _reason = _session_status_for_package(pkg)
         traced_steps, artifact_count, artifacts_path, operational_error = _package_progress_summary(run_root, pkg)
-        append_progress_event(
-            run_root,
-            "apprentice_attempt_completed",
-            run_id=run_root.name,
-            message=("Apprentice attempt failed - operational error" if operational_error else ("Follow-up %s Apprentice attempt complete" % followup_index if followup_index else "Apprentice attempt complete")),
-            current_loop=1,
-            maximum_improvement_loops=settings.max_improvement_loops,
-            phase="apprentice_attempt_complete",
-            traced_steps=traced_steps,
-            artifact_count=artifact_count,
-            artifacts_path=artifacts_path,
-            operational_error=operational_error,
-            metadata_json={"followup_index": followup_index} if followup_index else None,
-            callback=progress_callback,
-        )
-        state["apprentice_completed_emitted"] = True
+        if not state.get("apprentice_completed_emitted"):
+            append_progress_event(
+                run_root,
+                "apprentice_attempt_completed",
+                run_id=run_root.name,
+                message=("Apprentice attempt failed - operational error" if operational_error else ("Follow-up %s Apprentice attempt complete" % followup_index if followup_index else "Apprentice attempt complete")),
+                current_loop=1,
+                maximum_improvement_loops=settings.max_improvement_loops,
+                phase="apprentice_attempt_complete",
+                traced_steps=traced_steps,
+                artifact_count=artifact_count,
+                artifacts_path=artifacts_path,
+                operational_error=operational_error,
+                metadata_json={"followup_index": followup_index} if followup_index else None,
+                callback=progress_callback,
+            )
+            state["apprentice_completed_emitted"] = True
         if operational_error:
             return False
         pending, _ = _checkpoint_review_labels(settings)
+        review_packet = pkg / "loops" / "iterations" / "001" / "review_packet.md"
         append_progress_event(
             run_root,
             "mentor_review_started",
             run_id=run_root.name,
-            message=pending,
+            message=f"{pending} - review packet ready",
             current_loop=1,
             maximum_improvement_loops=settings.max_improvement_loops,
             phase="expert_review" if settings.mentor_mode == "expert_led" else "hybrid_human_approval",
-            metadata_json={"followup_index": followup_index} if followup_index else None,
+            metadata_json={
+                **({"followup_index": followup_index} if followup_index else {}),
+                "review_packet_ref": str(review_packet.relative_to(pkg)) if review_packet.exists() else None,
+                "review_packet_path": str(review_packet) if review_packet.exists() else None,
+            },
             callback=progress_callback,
         )
         update_run_status(
@@ -276,7 +388,15 @@ def _revision_decision_callback(
         )
         revision_path = run_root / "mentor_checkpoints" / "revision_checkpoint.json"
         revision = read_json(revision_path) if revision_path.exists() else {}
+        evaluation_path = run_root / "mentor_checkpoints" / "evaluation_checkpoint.json"
+        evaluation = read_json(evaluation_path) if evaluation_path.exists() else {}
         revision_requested = bool(revision.get("revision_should_run")) and settings.max_improvement_loops > 1
+        record_human_loop_feedback(
+            pkg,
+            iteration=1,
+            checkpoint={**evaluation, **revision, "evidence_refs": ["loops/iterations/001/review_packet.json", "loops/iterations/001/review_packet.md"]},
+            revision_requested=revision_requested,
+        )
         _, complete = _checkpoint_review_labels(settings, revision_requested)
         append_progress_event(
             run_root,
@@ -435,6 +555,56 @@ def _package_progress_summary(run_root: Path, pkg: Path) -> tuple[int, int, Path
     return traced_steps, artifact_count, artifacts_path, operational_error
 
 
+def _attempt_complete_callback(
+    run_root: Path,
+    settings: Settings,
+    *,
+    progress_callback: ProgressCallback | None,
+    followup_index: int | None = None,
+    state: dict[str, bool] | None = None,
+):
+    def _callback(pkg: Path, attempt_kind: str) -> None:
+        if attempt_kind != "baseline":
+            return
+        traced_steps, artifact_count, artifacts_path, operational_error = _package_progress_summary(run_root, pkg)
+        append_progress_event(
+            run_root,
+            "apprentice_attempt_completed",
+            run_id=run_root.name,
+            message=("Apprentice attempt failed - operational error" if operational_error else (f"Follow-up {followup_index} Apprentice attempt complete" if followup_index else "Apprentice attempt complete")),
+            current_loop=1,
+            maximum_improvement_loops=settings.max_improvement_loops,
+            phase="apprentice_attempt_complete",
+            traced_steps=traced_steps,
+            artifact_count=artifact_count,
+            artifacts_path=artifacts_path,
+            operational_error=operational_error,
+            metadata_json={"followup_index": followup_index} if followup_index else None,
+            callback=progress_callback,
+        )
+        if state is not None:
+            state["apprentice_completed_emitted"] = True
+        if not operational_error and not _human_checkpoint_mode(settings):
+            append_progress_event(
+                run_root,
+                "mentor_review_started",
+                run_id=run_root.name,
+                message=(f"Follow-up {followup_index} Mentor audit started" if followup_index else "Mentor audit started"),
+                current_loop=1,
+                maximum_improvement_loops=settings.max_improvement_loops,
+                phase="mentor_review",
+                traced_steps=traced_steps,
+                artifact_count=artifact_count,
+                artifacts_path=artifacts_path,
+                metadata_json={"followup_index": followup_index} if followup_index else None,
+                callback=progress_callback,
+            )
+            if state is not None:
+                state["mentor_review_started_emitted"] = True
+
+    return _callback
+
+
 def run_prompt_task(
     instruction: str,
     assets: list[Path] | None = None,
@@ -444,6 +614,7 @@ def run_prompt_task(
     create_bundle: bool = True,
     progress_callback: ProgressCallback | None = None,
     experience_pack_refs: list[dict] | None = None,
+    runtime_training_refs: list[dict] | None = None,
 ) -> tuple[Path, Path | None]:
     settings = settings or get_settings()
     run_id = run_id or make_run_id(instruction)
@@ -462,11 +633,13 @@ def run_prompt_task(
         maximum_improvement_loops=settings.max_improvement_loops,
         latest_message="Agent Apprenticeship run started.",
         apprentice_agent=apprentice_agent_display(settings),
+        apprenticeship_mode=settings.apprenticeship_mode,
         mentor_mode=settings.mentor_mode,
         task_title=title,
         task_workspace_path=str(run_root),
         artifacts_path=str(public_artifacts),
         **_experience_session_fields(experience_pack_refs),
+        **_runtime_training_session_fields(runtime_training_refs),
     )
     append_progress_event(
         run_root,
@@ -478,6 +651,10 @@ def run_prompt_task(
         phase="starting",
         run_status="running",
         task_status="running",
+        metadata_json={
+            "apprenticeship_mode": settings.apprenticeship_mode,
+            "mentor_mode": settings.mentor_mode,
+        },
         callback=progress_callback,
     )
     (run_root / "task").mkdir(exist_ok=True)
@@ -544,11 +721,13 @@ def run_prompt_task(
             "task_instruction": instruction,
             "task_assets": asset_refs,
             "mentor_mode": settings.mentor_mode,
+            "apprenticeship_mode": settings.apprenticeship_mode,
             "sensitive_info_masking": settings.sensitive_info_masking,
             "max_improvement_loops": settings.max_improvement_loops,
             "apprentice_agent": apprentice_agent_display(settings),
             "model_provider": settings.model_provider,
             **_experience_session_fields(experience_pack_refs),
+            **_runtime_training_session_fields(runtime_training_refs),
         },
     )
     _append_mentor_preparation_started(run_root, settings, progress_callback=progress_callback)
@@ -569,6 +748,12 @@ def run_prompt_task(
                     settings,
                     progress_callback=progress_callback,
                 ),
+                attempt_complete_callback=_attempt_complete_callback(
+                    run_root,
+                    settings,
+                    progress_callback=progress_callback,
+                    state=checkpoint_state,
+                ),
                 revision_decision_callback=revision_decider,
             )
     except KeyboardInterrupt as exc:
@@ -650,21 +835,22 @@ def run_prompt_task(
             callback=progress_callback,
         )
     if should_run_mentor_review and not _human_checkpoint_mode(settings):
-        append_progress_event(
-            run_root,
-            "mentor_review_started",
-            run_id=run_id,
-            message="Mentor review started",
-            current_loop=actual_iterations,
-            maximum_improvement_loops=settings.max_improvement_loops,
-            phase="mentor_review",
-            callback=progress_callback,
-        )
+        if not checkpoint_state.get("mentor_review_started_emitted"):
+            append_progress_event(
+                run_root,
+                "mentor_review_started",
+                run_id=run_id,
+                message="Mentor audit started",
+                current_loop=actual_iterations,
+                maximum_improvement_loops=settings.max_improvement_loops,
+                phase="mentor_review",
+                callback=progress_callback,
+            )
         append_progress_event(
             run_root,
             "mentor_review_completed",
             run_id=run_id,
-            message=f"Mentor review complete - task {run_status}",
+            message=f"Mentor audit complete - task {run_status}",
             current_loop=actual_iterations,
             maximum_improvement_loops=settings.max_improvement_loops,
             phase="mentor_review_complete",
@@ -681,6 +867,7 @@ def run_prompt_task(
             auto_approve=_checkpoint_auto_approve(settings),
             stages=("final_approval",),
         )
+        _record_final_approval_loop_feedback(run_root, settings)
     append_session_event(
         run_root,
         event_type="agent_attempt",
@@ -702,11 +889,13 @@ def run_prompt_task(
         "latest_package": str(pkg.relative_to(run_root)),
         "latest_attempt_id": manifest.get("selected_attempt_id"),
         "mentor_mode": settings.mentor_mode,
+        "apprenticeship_mode": settings.apprenticeship_mode,
         "sensitive_info_masking": settings.sensitive_info_masking,
         "max_improvement_loops": settings.max_improvement_loops,
         "apprentice_agent": apprentice_agent_display(settings),
         "model_provider": settings.model_provider,
         **_experience_session_fields(experience_pack_refs),
+        **_runtime_training_session_fields(runtime_training_refs),
     }
     if partial_reason:
         session_data["status_reason"] = partial_reason
@@ -716,6 +905,20 @@ def run_prompt_task(
     )
     bundle = None
     if create_bundle:
+        append_progress_event(
+            run_root,
+            "task_outputs_ready",
+            run_id=run_id,
+            message=f"Task {run_status}. Artifacts are available at: {artifacts_path}",
+            current_loop=actual_iterations,
+            maximum_improvement_loops=settings.max_improvement_loops,
+            phase="task_outputs_ready",
+            traced_steps=traced_steps,
+            artifact_count=artifact_count,
+            artifacts_path=artifacts_path,
+            callback=progress_callback,
+        )
+        _safe_run_tdo_for_run(run_root, settings, progress_callback=progress_callback)
         if _human_checkpoint_mode(settings) and not should_run_mentor_review:
             write_mentor_checkpoints(
                 run_root,
@@ -723,23 +926,24 @@ def run_prompt_task(
                 auto_approve=_checkpoint_auto_approve(settings),
                 stages=("final_approval",),
             )
+            _record_final_approval_loop_feedback(run_root, settings)
         append_progress_event(
             run_root,
             "contribution_bundle_started",
             run_id=run_id,
-            message="Contribution Bundle packaging started",
+            message="Experience Compilation packaging started",
             current_loop=actual_iterations,
             maximum_improvement_loops=settings.max_improvement_loops,
             phase="contribution_bundle",
             callback=progress_callback,
         )
         bundle = create_contribution_bundle(run_root, settings=settings)
-        _update_bundle_experience_metadata(bundle, experience_pack_refs)
+        _update_bundle_experience_metadata(bundle, experience_pack_refs, runtime_training_refs)
         append_progress_event(
             run_root,
             "contribution_bundle_completed",
             run_id=run_id,
-            message="Contribution Bundle ready",
+            message="Experience Compilation ready",
             current_loop=actual_iterations,
             maximum_improvement_loops=settings.max_improvement_loops,
             phase="contribution_bundle_complete",
@@ -763,6 +967,7 @@ def run_prompt_task(
         operational_error=operational_error,
         callback=progress_callback,
     )
+    update_run_status(run_root, **_runtime_training_session_fields(runtime_training_refs))
     return run_root, bundle
 
 
@@ -781,22 +986,61 @@ def _experience_session_fields(experience_pack_refs: list[dict] | None) -> dict:
     }
 
 
-def _update_json_experience_metadata(path: Path, experience_pack_refs: list[dict] | None) -> None:
-    if not experience_pack_refs or not path.exists():
+def _runtime_training_session_fields(runtime_training_refs: list[dict] | None) -> dict:
+    refs = runtime_training_refs or []
+    if not refs:
+        return {
+            "runtime_training_used": False,
+            "installed_skill_refs": [],
+            "installed_skill_ids": [],
+        }
+    return {
+        "runtime_training_used": True,
+        "installed_skill_refs": refs,
+        "installed_skill_ids": [ref.get("installed_skill_id") for ref in refs if ref.get("installed_skill_id")],
+        "runtime_training_selection_reason": "enabled installed runtime training matched this task or was explicitly requested",
+    }
+
+
+def _update_json_experience_metadata(path: Path, experience_pack_refs: list[dict] | None, runtime_training_refs: list[dict] | None = None) -> None:
+    if not (experience_pack_refs or runtime_training_refs) or not path.exists():
         return
     data = read_json(path)
     if not isinstance(data, dict):
         return
-    data.update(_experience_session_fields(experience_pack_refs))
-    data["experience_learning_status"] = "experience_pack_applied"
+    if experience_pack_refs:
+        data.update(_experience_session_fields(experience_pack_refs))
+        data["experience_learning_status"] = "experience_pack_applied"
+    if runtime_training_refs:
+        data.update(_runtime_training_session_fields(runtime_training_refs))
     write_json(path, data)
 
 
-def _update_bundle_experience_metadata(bundle: Path | None, experience_pack_refs: list[dict] | None) -> None:
-    if not bundle or not experience_pack_refs:
+def _update_trace_experience_metadata(path: Path, experience_pack_refs: list[dict] | None, runtime_training_refs: list[dict] | None = None) -> None:
+    if not (experience_pack_refs or runtime_training_refs) or not path.exists():
+        return
+    data = read_json(path)
+    if not isinstance(data, dict):
+        return
+    metadata = data.setdefault("metadata_json", {})
+    if not isinstance(metadata, dict):
+        metadata = {}
+        data["metadata_json"] = metadata
+    if experience_pack_refs:
+        metadata.update(_experience_session_fields(experience_pack_refs))
+        metadata["experience_learning_status"] = "experience_pack_applied"
+    if runtime_training_refs:
+        metadata.update(_runtime_training_session_fields(runtime_training_refs))
+    write_json(path, data)
+
+
+def _update_bundle_experience_metadata(bundle: Path | None, experience_pack_refs: list[dict] | None, runtime_training_refs: list[dict] | None = None) -> None:
+    if not bundle or not (experience_pack_refs or runtime_training_refs):
         return
     for rel in ("contribution_manifest.json", "session_metadata.json"):
-        _update_json_experience_metadata(bundle / rel, experience_pack_refs)
+        _update_json_experience_metadata(bundle / rel, experience_pack_refs, runtime_training_refs)
+    for trace_path in bundle.glob("attempts/*/agent_trace.json"):
+        _update_trace_experience_metadata(trace_path, experience_pack_refs, runtime_training_refs)
 
 
 def _latest_attempt_id(run_root: Path) -> str | None:
@@ -810,6 +1054,43 @@ def _latest_attempt_id(run_root: Path) -> str | None:
     return None
 
 
+def _latest_package(run_root: Path) -> Path | None:
+    packages = sorted((run_root / "packages").glob("*")) if (run_root / "packages").exists() else []
+    return packages[-1] if packages else None
+
+
+def _record_final_approval_loop_feedback(run_root: Path, settings: Settings) -> None:
+    if not _human_checkpoint_mode(settings):
+        return
+    pkg = _latest_package(run_root)
+    if not pkg:
+        return
+    final_path = run_root / "mentor_checkpoints" / "final_approval_checkpoint.json"
+    if not final_path.exists():
+        return
+    try:
+        final = read_json(final_path)
+    except Exception:
+        return
+    manifest_path = pkg / "loops" / "loop_manifest.json"
+    if not manifest_path.exists():
+        return
+    manifest = read_json(manifest_path)
+    iterations = [item for item in manifest.get("iterations") or [] if isinstance(item, dict)]
+    if not iterations:
+        return
+    iteration = max(int(item.get("loop_iteration") or 0) for item in iterations)
+    if iteration <= 0:
+        return
+    review_refs = [
+        f"loops/iterations/{iteration:03d}/review_packet.json",
+        f"loops/iterations/{iteration:03d}/review_packet.md",
+    ]
+    final_with_refs = {**final, "evidence_refs": review_refs}
+    approved = bool(final.get("approved_for_local_bundle", True))
+    record_human_loop_feedback(pkg, iteration=iteration, checkpoint=final_with_refs, revision_requested=not approved)
+
+
 def _session_task_id(run_root: Path) -> str | None:
     session_path = run_root / "session.json"
     if session_path.exists():
@@ -938,6 +1219,13 @@ def continue_session(
                     progress_callback=progress_callback,
                     followup_index=followup_index,
                 ),
+                attempt_complete_callback=_attempt_complete_callback(
+                    run_root,
+                    settings,
+                    progress_callback=progress_callback,
+                    followup_index=followup_index,
+                    state=checkpoint_state,
+                ),
                 revision_decision_callback=revision_decider,
             )
         manifest = read_json(pkg / "package_manifest.json") if (pkg / "package_manifest.json").exists() else {}
@@ -1009,7 +1297,7 @@ def continue_session(
                 run_root,
                 "mentor_review_completed",
                 run_id=run_root.name,
-                message=f"Follow-up {followup_index} mentor review complete",
+                message=f"Follow-up {followup_index} mentor audit complete",
                 current_loop=actual_iterations,
                 maximum_improvement_loops=settings.max_improvement_loops,
                 phase="mentor_review_complete",
@@ -1027,6 +1315,7 @@ def continue_session(
                 auto_approve=_checkpoint_auto_approve(settings),
                 stages=("final_approval",),
             )
+            _record_final_approval_loop_feedback(run_root, settings)
         append_session_event(
             run_root,
             event_type="agent_attempt",
@@ -1068,16 +1357,25 @@ def continue_session(
         final_artifact_count = None
         final_operational_error = None
         record_only_message = "Follow-up recorded. No Apprentice Agent loop was run. Use --run-loop to continue work."
-    append_progress_event(
+        record_followup_review_update(
+            run_root,
+            followup_index=followup_index,
+            record_only=True,
+            note=record_only_message,
+        )
+    if run_loop:
+        record_followup_review_update(
+            run_root,
+            followup_index=followup_index,
+            record_only=False,
+            note=f"Follow-up {followup_index} ran a new Apprentice Agent loop and produced a new review packet.",
+        )
+    _safe_run_tdo_for_run(
         run_root,
-        "contribution_bundle_started",
-        run_id=run_root.name,
-        message="Contribution Bundle update started",
-        current_loop=1,
-        maximum_improvement_loops=settings.max_improvement_loops,
-        phase="contribution_bundle",
-        metadata_json={"followup_index": followup_index},
-        callback=progress_callback,
+        settings,
+        progress_callback=progress_callback,
+        followup_index=followup_index,
+        record_only=not run_loop,
     )
     if run_loop and _human_checkpoint_mode(settings):
         write_mentor_checkpoints(
@@ -1087,12 +1385,24 @@ def continue_session(
             stages=("final_approval",),
             preserve_interactive=False,
         )
+        _record_final_approval_loop_feedback(run_root, settings)
+    append_progress_event(
+        run_root,
+        "contribution_bundle_started",
+        run_id=run_root.name,
+        message="Experience Compilation update started",
+        current_loop=1,
+        maximum_improvement_loops=settings.max_improvement_loops,
+        phase="contribution_bundle",
+        metadata_json={"followup_index": followup_index},
+        callback=progress_callback,
+    )
     bundle = create_contribution_bundle(run_root, settings=settings)
     append_progress_event(
         run_root,
         "contribution_bundle_completed",
         run_id=run_root.name,
-        message="Contribution Bundle updated",
+        message="Experience Compilation updated",
         current_loop=1,
         maximum_improvement_loops=settings.max_improvement_loops,
         phase="contribution_bundle_complete",
@@ -1121,7 +1431,7 @@ def continue_session(
     return run_root, bundle
 
 
-def finish_session(run_id: str, settings: Settings | None = None) -> tuple[Path, Path]:
+def finish_session(run_id: str, settings: Settings | None = None, progress_callback: ProgressCallback | None = None) -> tuple[Path, Path]:
     settings = settings or get_settings()
     run_root = run_root_for(run_id, settings)
     if not run_root.exists():
@@ -1155,6 +1465,8 @@ def finish_session(run_id: str, settings: Settings | None = None) -> tuple[Path,
         auto_approve=_checkpoint_auto_approve(settings),
         stages=("final_approval",),
     )
+    _record_final_approval_loop_feedback(run_root, settings)
+    _safe_run_tdo_for_run(run_root, settings, progress_callback=progress_callback)
     bundle = create_contribution_bundle(run_root, settings=settings)
     append_progress_event(
         run_root,