agent-apprenticeship 0.1.6 → 0.1.8

package/bin/agent-apprenticeship.js

@@ -4,7 +4,7 @@
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
-const { spawnSync } = require("child_process");
+const { spawn, spawnSync } = require("child_process");
 
 const packageRoot = path.resolve(__dirname, "..");
 const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
@@ -103,26 +103,69 @@ function setupTimeout(defaultMs) {
   return Number.isFinite(value) && value > 0 ? value : defaultMs;
 }
 
+function appendLimited(current, chunk, limit = 16000) {
+  const next = current + chunk.toString();
+  return next.length > limit ? next.slice(next.length - limit) : next;
+}
+
+function setupHeartbeatMs(defaultMs) {
+  const raw = process.env.AA_NPM_SETUP_HEARTBEAT_MS;
+  if (!raw) return defaultMs;
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : defaultMs;
+}
+
 function runQuiet(command, args, label, timeoutMs) {
-  const result = spawnSync(command, args, {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-    env: runtimeEnv(),
-    timeout: setupTimeout(timeoutMs)
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: runtimeEnv()
+    });
+    const heartbeat = setInterval(() => {
+      console.error(`Still working: ${label}...`);
+    }, setupHeartbeatMs(30000));
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!settled) child.kill("SIGKILL");
+      }, 3000).unref();
+    }, setupTimeout(timeoutMs));
+    child.stdout.on("data", (chunk) => {
+      stdout = appendLimited(stdout, chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = appendLimited(stderr, chunk);
+    });
+    child.on("error", (error) => {
+      settled = true;
+      clearInterval(heartbeat);
+      clearTimeout(timeout);
+      console.error(`Agent Apprenticeship runtime setup failed while trying to ${label}.`);
+      console.error(String(error.message || error));
+      process.exit(1);
+    });
+    child.on("close", (code, signal) => {
+      settled = true;
+      clearInterval(heartbeat);
+      clearTimeout(timeout);
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      console.error(`Agent Apprenticeship runtime setup failed while trying to ${label}.`);
+      if (timedOut || signal) {
+        console.error("Runtime setup timed out. Re-run the command, or set AA_PYTHON to a working Python 3.11+ interpreter.");
+      }
+      const out = [stdout, stderr].filter(Boolean).join("\n").trim();
+      if (out) console.error(out.slice(-8000));
+      process.exit(code || 1);
+    });
   });
-  if (result.error || result.status !== 0) {
-    console.error(`Agent Apprenticeship runtime setup failed while trying to ${label}.`);
-    const timedOut = Boolean(result.signal) || (result.error && String(result.error.message || result.error).includes("ETIMEDOUT"));
-    if (timedOut) {
-      console.error("Runtime setup timed out. Re-run the command, or set AA_PYTHON to a working Python 3.11+ interpreter.");
-    } else if (result.error) {
-      const message = String(result.error.message || result.error);
-      console.error(message);
-    }
-    const out = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
-    if (out) console.error(out.slice(-8000));
-    process.exit(result.status || 1);
-  }
 }
 
 function runVisible(command, args, label) {
@@ -137,7 +180,7 @@ function runVisible(command, args, label) {
   }
 }
 
-function ensureRuntime(python) {
+async function ensureRuntime(python) {
   const venvDir = path.resolve(process.env.AA_NPM_VENV || path.join(appHome(), "npm-venv", packageJson.version));
   const py = venvPython(venvDir);
   const markerPath = path.join(venvDir, ".agent-apprenticeship-npm.json");
@@ -154,8 +197,8 @@ function ensureRuntime(python) {
   console.error("First run can take a few minutes while Python dependencies are installed.");
   fs.rmSync(venvDir, { recursive: true, force: true });
   fs.mkdirSync(path.dirname(venvDir), { recursive: true });
-  runQuiet(python, ["-m", "venv", venvDir], "create the Python environment", 120000);
-  runQuiet(py, [
+  await runQuiet(python, ["-m", "venv", venvDir], "create the Python environment", 120000);
+  await runQuiet(py, [
     "-m", "pip", "install",
     "--disable-pip-version-check",
     "--progress-bar", "off",
@@ -191,20 +234,25 @@ function runCli(python, args, usePackagedSource) {
   process.exit(result.status === null ? 1 : result.status);
 }
 
-const python = findPython();
-if (!python) {
-  console.error("Agent Apprenticeship requires Python 3.11 or newer.");
-  console.error("");
-  console.error("macOS Homebrew:");
-  console.error("brew install python@3.11");
-  console.error("");
-  console.error("Or set:");
-  console.error("AA_PYTHON=/path/to/python3.11");
-  process.exit(1);
-}
+(async () => {
+  const python = findPython();
+  if (!python) {
+    console.error("Agent Apprenticeship requires Python 3.11 or newer.");
+    console.error("");
+    console.error("macOS Homebrew:");
+    console.error("brew install python@3.11");
+    console.error("");
+    console.error("Or set:");
+    console.error("AA_PYTHON=/path/to/python3.11");
+    process.exit(1);
+  }
 
-if (process.env.AA_NPM_USE_SYSTEM_PYTHON === "1") {
-  runCli(python, process.argv.slice(2), true);
-}
+  if (process.env.AA_NPM_USE_SYSTEM_PYTHON === "1") {
+    runCli(python, process.argv.slice(2), true);
+  }
 
-runCli(ensureRuntime(python), process.argv.slice(2), false);
+  runCli(await ensureRuntime(python), process.argv.slice(2), false);
+})().catch((error) => {
+  console.error(`Failed to start Agent Apprenticeship: ${error.message || error}`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-apprenticeship",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "The living ecosystem for AI agents learning from real-world work through iterative loops and training-signal exchange.",
   "license": "MIT",
   "repository": {

package/pyproject.toml

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

package/src/agent_apprenticeship_trace/__init__.py

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

package/src/agent_apprenticeship_trace/actual_outputs_normalizer.py

@@ -5,6 +5,7 @@ from typing import Any
 from pydantic import BaseModel, Field
 from .schemas import ActualOutputs
 from .io import write_json
+from .openai_structured import extract_json_object
 
 CANONICAL_ACTUAL_FIELDS = set(ActualOutputs.model_fields.keys())
 
@@ -72,7 +73,15 @@ def _validation_errors(exc: Exception) -> list[str]:
 
 
 def _norm_ref(ref: str, attempt_kind: str) -> str:
-    ref=str(ref)
+    ref=str(ref).replace("\\", "/").strip().lstrip("/")
+    while ref.startswith("./"):
+        ref = ref[2:]
+    if not ref:
+        return ref
+    if ref in {"actual_outputs.json", "agent_trace.json", "stdout.txt", "stderr.txt", "final_message.txt"}:
+        return f"attempts/{attempt_kind}/{ref}"
+    if ref.startswith("input/") or ref.startswith("task/"):
+        return ref
     if ref.startswith(f'attempts/{attempt_kind}/'):
         return ref
     if ref.startswith('artifacts/'):
@@ -82,11 +91,50 @@ def _norm_ref(ref: str, attempt_kind: str) -> str:
     return ref
 
 
+def _is_input_ref(ref: str) -> bool:
+    return ref.startswith("input/") or ref.startswith("task/") or "/input/" in ref or "/task/" in ref
+
+
+def _is_attempt_metadata_ref(ref: str, attempt_kind: str) -> bool:
+    return ref in {
+        f"attempts/{attempt_kind}/actual_outputs.json",
+        f"attempts/{attempt_kind}/agent_trace.json",
+        f"attempts/{attempt_kind}/stdout.txt",
+        f"attempts/{attempt_kind}/stderr.txt",
+        f"attempts/{attempt_kind}/final_message.txt",
+    }
+
+
+def _generated_ref_list(value: Any, attempt_kind: str) -> list[str]:
+    refs=[]
+    for item in _as_list(value):
+        if not isinstance(item, str):
+            continue
+        normalized=_norm_ref(item, attempt_kind)
+        if _is_input_ref(normalized) or _is_attempt_metadata_ref(normalized, attempt_kind):
+            continue
+        if normalized and normalized not in refs:
+            refs.append(normalized)
+    return refs
+
+
+def _input_ref_list(value: Any, attempt_kind: str) -> list[str]:
+    refs=[]
+    for item in _as_list(value):
+        if not isinstance(item, str):
+            continue
+        normalized=_norm_ref(item, attempt_kind)
+        if normalized and _is_input_ref(normalized) and normalized not in refs:
+            refs.append(normalized)
+    return refs
+
+
 def _artifact_paths_from_raw(raw: dict[str, Any]) -> dict[str, Any]:
     found={}
     for k,v in raw.items():
-        if isinstance(k, str) and (k.startswith('artifacts/') or '/artifacts/' in k):
-            found[k]=v
+        key = k[2:] if isinstance(k, str) and k.startswith("./") else k
+        if isinstance(key, str) and (key.startswith('artifacts/') or '/artifacts/' in key):
+            found[key]=v
     return found
 
 
@@ -102,35 +150,52 @@ def _scan_existing_artifacts(ctx: ActualOutputsNormalizationContext) -> list[str
     return refs
 
 
-def _extract_refs(raw: dict[str, Any], ctx: ActualOutputsNormalizationContext) -> tuple[list[str], dict[str, Any], list[str]]:
+def _extract_refs(raw: dict[str, Any], ctx: ActualOutputsNormalizationContext) -> tuple[list[str], list[str], dict[str, Any], list[str]]:
     warnings=[]
     refs=[]
+    input_refs=[]
     original_path_fields=_artifact_paths_from_raw(raw)
     for k in original_path_fields:
-        refs.append(_norm_ref(k, ctx.attempt_kind))
+        normalized = _norm_ref(k, ctx.attempt_kind)
+        (input_refs if _is_input_ref(normalized) else refs).append(normalized)
     for key in ['deliverable_refs','artifact_refs','files_created','outputs','artifacts','output_files']:
         val=raw.get(key)
         if isinstance(val, dict):
             for k in val:
                 if isinstance(k, str) and (k.startswith('artifacts/') or '/artifacts/' in k or '.' in Path(k).name):
-                    refs.append(_norm_ref(k, ctx.attempt_kind))
+                    normalized = _norm_ref(k, ctx.attempt_kind)
+                    if _is_input_ref(normalized):
+                        input_refs.append(normalized)
+                    elif not _is_attempt_metadata_ref(normalized, ctx.attempt_kind):
+                        refs.append(normalized)
         else:
             for item in _as_list(val):
                 if isinstance(item, str):
-                    refs.append(_norm_ref(item, ctx.attempt_kind))
+                    normalized = _norm_ref(item, ctx.attempt_kind)
+                    if _is_input_ref(normalized):
+                        input_refs.append(normalized)
+                    elif not _is_attempt_metadata_ref(normalized, ctx.attempt_kind):
+                        refs.append(normalized)
+    for item in _as_list(raw.get("input_artifact_refs")):
+        if isinstance(item, str):
+            input_refs.append(_norm_ref(item, ctx.attempt_kind))
     existing=_scan_existing_artifacts(ctx)
     refs.extend(existing)
     dedup=[]
     for r in refs:
         if r and r not in dedup:
             dedup.append(r)
-    return dedup, original_path_fields, warnings
+    input_dedup=[]
+    for r in input_refs:
+        if r and r not in input_dedup:
+            input_dedup.append(r)
+    return dedup, input_dedup, original_path_fields, warnings
 
 
 def normalize_actual_outputs(raw: dict[str, Any] | None, ctx: ActualOutputsNormalizationContext) -> ActualOutputsNormalizationResult:
     raw = dict(raw or {})
     report=ActualOutputsNormalizationReport(task_id=ctx.task_id, attempt_id=ctx.attempt_id, attempt_kind=ctx.attempt_kind, actual_outputs_raw_count=1)
-    refs, original_path_fields, warnings = _extract_refs(raw, ctx)
+    refs, input_refs, original_path_fields, warnings = _extract_refs(raw, ctx)
     original_fields={k:v for k,v in raw.items() if k not in CANONICAL_ACTUAL_FIELDS}
     raw_status=str(raw.get('status') or '').lower()
     failure_status=raw_status in {'failed','error','timeout'}
@@ -156,13 +221,14 @@ def normalize_actual_outputs(raw: dict[str, Any] | None, ctx: ActualOutputsNorma
         'attempt_kind': str(raw.get('attempt_kind') or ctx.attempt_kind),
         'status': status,
         'output_summary': str(summary),
-        'primary_output_ref': raw.get('primary_output_ref') or (refs[0] if refs else None),
-        'deliverable_refs': [str(x) for x in (raw.get('deliverable_refs') if isinstance(raw.get('deliverable_refs'), list) else [])] or refs,
+        'primary_output_ref': _generated_ref_list(raw.get('primary_output_ref'), ctx.attempt_kind)[0] if _generated_ref_list(raw.get('primary_output_ref'), ctx.attempt_kind) else (refs[0] if refs else None),
+        'input_artifact_refs': _input_ref_list(raw.get('input_artifact_refs'), ctx.attempt_kind) or input_refs,
+        'deliverable_refs': _generated_ref_list(raw.get('deliverable_refs'), ctx.attempt_kind) or refs,
         'final_message_ref': raw.get('final_message_ref') or f'attempts/{ctx.attempt_kind}/final_message.txt',
-        'artifact_refs': [str(x) for x in (raw.get('artifact_refs') if isinstance(raw.get('artifact_refs'), list) else [])] or refs,
-        'files_created': [str(x) for x in (raw.get('files_created') if isinstance(raw.get('files_created'), list) else [])] or refs,
-        'files_modified': [str(x) for x in (raw.get('files_modified') if isinstance(raw.get('files_modified'), list) else [])],
-        'files_deleted': [str(x) for x in (raw.get('files_deleted') if isinstance(raw.get('files_deleted'), list) else [])],
+        'artifact_refs': _generated_ref_list(raw.get('artifact_refs'), ctx.attempt_kind) or refs,
+        'files_created': _generated_ref_list(raw.get('files_created'), ctx.attempt_kind) or refs,
+        'files_modified': [_norm_ref(str(x), ctx.attempt_kind) for x in (raw.get('files_modified') if isinstance(raw.get('files_modified'), list) else [])],
+        'files_deleted': [_norm_ref(str(x), ctx.attempt_kind) for x in (raw.get('files_deleted') if isinstance(raw.get('files_deleted'), list) else [])],
         'stdout_ref': raw.get('stdout_ref') or f'attempts/{ctx.attempt_kind}/stdout.txt',
         'stderr_ref': raw.get('stderr_ref') or f'attempts/{ctx.attempt_kind}/stderr.txt',
         'raw_log_refs': [str(x) for x in (raw.get('raw_log_refs') if isinstance(raw.get('raw_log_refs'), list) else [])] or [f'attempts/{ctx.attempt_kind}/stdout.txt', f'attempts/{ctx.attempt_kind}/stderr.txt', f'attempts/{ctx.attempt_kind}/final_message.txt'],
@@ -201,24 +267,32 @@ def repair_actual_outputs_file(path: Path, ctx: ActualOutputsNormalizationContex
     text=path.read_text()
     raw_path=path.with_name('actual_outputs.raw.json')
     raw_path.write_text(text)
+    json_meta: dict[str, Any] = {}
+    parse_warnings: list[str] = []
     try:
         raw=json.loads(text)
         if not isinstance(raw, dict):
             raise ValueError('actual_outputs JSON was not an object')
-    except Exception as exc:
-        report.actual_outputs_fallback=True
-        report.actual_outputs_fallback_count=1
-        report.validation_errors.append(str(exc))
-        return ActualOutputsNormalizationResult(actual_outputs=None, report=report, fallback_required=True, parse_error=str(exc))
+    except Exception as first_exc:
+        try:
+            raw, json_meta = extract_json_object(text, return_metadata=True)
+            if not isinstance(raw, dict):
+                raise ValueError('actual_outputs JSON was not an object')
+            parse_warnings.append(f"actual_outputs parsed from embedded JSON after raw parse failed: {first_exc}")
+        except Exception as exc:
+            report.actual_outputs_fallback=True
+            report.actual_outputs_fallback_count=1
+            report.validation_errors.append(str(first_exc))
+            if str(exc) != str(first_exc):
+                report.validation_errors.append(str(exc))
+            return ActualOutputsNormalizationResult(actual_outputs=None, report=report, fallback_required=True, parse_error=str(first_exc))
     try:
-        valid=ActualOutputs.model_validate(raw).model_dump(mode='json')
-        result=ActualOutputsNormalizationResult(actual_outputs=valid, report=report)
-        result.report.actual_outputs_raw_count=1
-        result.report.actual_outputs_schema_valid=True
-        result.report.actual_outputs_schema_valid_count=1
-        result.report.actual_outputs_normalized=False
-        result.report.actual_outputs_normalized_count=0
-        result.report.actual_outputs_inferred_artifact_count=len(valid.get('deliverable_refs') or [])
+        ActualOutputs.model_validate(raw)
+        result=normalize_actual_outputs(raw, ctx)
+        result.report.raw_outputs_ref='actual_outputs.raw.json'
+        result.report.canonical_outputs_ref='actual_outputs.json'
+        result.report.warnings.extend(parse_warnings)
+        result.report.metadata_json.update(json_meta)
         return result
     except Exception as exc:
         path.with_name('actual_outputs.invalid.json').write_text(text)
@@ -228,6 +302,8 @@ def repair_actual_outputs_file(path: Path, ctx: ActualOutputsNormalizationContex
         result.report.normalized_outputs_ref='actual_outputs.normalized.json'
         result.report.canonical_outputs_ref='actual_outputs.json'
         result.report.validation_errors.extend(_validation_errors(exc))
+        result.report.warnings.extend(parse_warnings)
+        result.report.metadata_json.update(json_meta)
         return result
 
 

package/src/agent_apprenticeship_trace/apprentice_adapters.py

@@ -204,11 +204,13 @@ def build_agent_invocation(agent_id: str, command: str, workspace: Path, prompt_
 def classify_agent_failure(agent_id: str, display_name: str, error: object | None, stdout: str = "", stderr: str = "", returncode: int | None = None) -> str | None:
     text = f"{error or ''}\n{stdout or ''}\n{stderr or ''}".lower()
     command = WORKER_AGENT_RECIPES.get(agent_id).command_name if agent_id in WORKER_AGENT_RECIPES else agent_id
+    if error is None and returncode == 0:
+        return None
     if isinstance(error, FileNotFoundError) or f"no such file or directory: '{command}'" in text or f"no such file or directory: {command}" in text:
         return f"Apprentice Agent command not found: {command}"
     if "headless mode unavailable" in text or "headless execution is unavailable" in text:
         return str(error or stderr).strip()
-    if isinstance(error, subprocess.TimeoutExpired) or "timed out" in text or "timeout" in text:
+    if isinstance(error, subprocess.TimeoutExpired) or "timed out" in text or "timeout expired" in text or "command timed out" in text:
         return f"Apprentice Agent attempt timed out while running {display_name}."
     if _has_any(text, "eperm", "permission denied", "operation not permitted", "read-only file system"):
         return f"Apprentice Agent permission error while running {display_name}: the external CLI could not access a required file or directory."

package/src/agent_apprenticeship_trace/artifact_resolver.py

@@ -41,6 +41,8 @@ def normalize_artifact_ref(ref: object) -> str:
 
     value = "" if ref is None else str(ref)
     value = value.strip().strip('"').strip("'").replace("\\", "/").strip()
+    while value.startswith("./"):
+        value = value[2:]
 
     for prefix in (
         "artifact_content_previews_truncated:",
@@ -101,6 +103,8 @@ def is_artifact_evidence_ref(ref: object) -> bool:
         "trace_summary_json:",
         "actual_outputs:",
         "actual_outputs.",
+        "actual_outputs.json",
+        "agent_trace.json",
         "rubric:",
         "rubric.",
         "score:",
@@ -113,6 +117,8 @@ def is_artifact_evidence_ref(ref: object) -> bool:
     return (
         ("attempts/" in normalized and "/artifacts/" in normalized)
         or normalized.startswith("artifacts/")
+        or normalized.startswith("input/")
+        or normalized.startswith("task/")
         or ("packages/" in normalized and "/attempts/" in normalized and "/artifacts/" in normalized)
     )
 

package/src/agent_apprenticeship_trace/bundle_exporter.py

@@ -6,10 +6,12 @@ import re
 from pathlib import Path
 from typing import Any
 
-from .config import Settings, get_settings, normalize_mentor_mode
+from .config import Settings, apprenticeship_mode_display, get_settings, normalize_apprenticeship_mode, normalize_mentor_mode
 from .io import append_jsonl, read_json, read_jsonl, write_json
 from .public_sanitizer import sanitize_public_obj, sanitize_public_text
 from .release_exporter import create_release
+from .tdo import tdo_manifest_fields_from_report
+from .loop_review import summarize_loop_reviews
 
 
 def _count_jsonl(path: Path) -> int:
@@ -96,7 +98,7 @@ def contribution_counts(release_root: Path) -> dict[str, int]:
 
 def _write_card(bundle_root: Path) -> None:
     (bundle_root / "contribution_card.md").write_text(
-        "# Agent Apprenticeship Contribution Bundle\n\n"
+        "# Agent Apprenticeship Agent Experience Package\n\n"
         "This local bundle packages an apprenticeship session for public ecosystem contribution. "
         "It includes session events, task instructions, traces, actual outputs, evaluation results, "
         "and learning-data views when available.\n\n"
@@ -110,6 +112,15 @@ def _session_mentor_mode(session: dict[str, Any], settings: Settings) -> str:
     return normalize_mentor_mode(session.get("mentor_mode") or session.get("evaluation_mode") or settings.mentor_mode)
 
 
+def _session_apprenticeship_mode(session: dict[str, Any], settings: Settings) -> str:
+    return normalize_apprenticeship_mode(
+        session.get("apprenticeship_mode")
+        or session.get("mentor_mode")
+        or session.get("evaluation_mode")
+        or settings.apprenticeship_mode
+    )
+
+
 def _clean_session_metadata(session: dict[str, Any], settings: Settings) -> dict[str, Any]:
     allowed = {
         "run_id",
@@ -128,6 +139,8 @@ def _clean_session_metadata(session: dict[str, Any], settings: Settings) -> dict
         "session_status",
     }
     clean = {k: v for k, v in session.items() if k in allowed and v is not None}
+    clean["apprenticeship_mode"] = _session_apprenticeship_mode(session, settings)
+    clean["apprenticeship_mode_display"] = apprenticeship_mode_display(clean["apprenticeship_mode"])
     clean["mentor_mode"] = _session_mentor_mode(session, settings)
     return clean
 
@@ -141,6 +154,8 @@ def _copy_session_files(run_root: Path, bundle_root: Path, settings: Settings) -
         shutil.copytree(run_root / "task", bundle_root / "task", dirs_exist_ok=True)
     if (run_root / "mentor_checkpoints").exists():
         shutil.copytree(run_root / "mentor_checkpoints", bundle_root / "mentor_checkpoints", dirs_exist_ok=True)
+    if (run_root / "loops").exists():
+        shutil.copytree(run_root / "loops", bundle_root / "loops", dirs_exist_ok=True)
 
 
 def _copy_clean_bundle_files(release_root: Path, bundle_root: Path, include_debug: bool) -> None:
@@ -153,6 +168,9 @@ def _copy_clean_bundle_files(release_root: Path, bundle_root: Path, include_debu
     _copy_jsonl_if_nonempty(release_root / "actual_outputs.jsonl", bundle_root / "outputs" / "actual_outputs.jsonl")
     _copy_json_if_exists(release_root / "artifacts_index.json", bundle_root / "outputs" / "artifacts_index.json")
     _copy_indexed_package_files(release_root, bundle_root)
+    _copy_tdo_outputs(release_root, bundle_root)
+    _copy_experience_compiler_outputs(release_root, bundle_root)
+    _copy_loop_review_outputs(release_root, bundle_root)
 
     for name in [
         "grader_results.jsonl",
@@ -214,6 +232,42 @@ def _copy_indexed_package_files(release_root: Path, bundle_root: Path) -> None:
     write_json(bundle_root / "outputs" / "artifacts_index.json", rewritten)
 
 
+def _copy_tdo_outputs(release_root: Path, bundle_root: Path) -> None:
+    package_tdo_dirs = sorted(path for path in (release_root / "packages").glob("*/tdo") if path.is_dir())
+    if not package_tdo_dirs:
+        return
+    if len(package_tdo_dirs) == 1:
+        shutil.copytree(package_tdo_dirs[0], bundle_root / "tdo", dirs_exist_ok=True)
+        return
+    for src in package_tdo_dirs:
+        target = bundle_root / "tdo" / src.parent.name
+        shutil.copytree(src, target, dirs_exist_ok=True)
+
+
+def _copy_experience_compiler_outputs(release_root: Path, bundle_root: Path) -> None:
+    package_dirs = sorted(path for path in (release_root / "packages").glob("*/experience_compiler") if path.is_dir())
+    if not package_dirs:
+        return
+    if len(package_dirs) == 1:
+        shutil.copytree(package_dirs[0], bundle_root / "experience_compiler", dirs_exist_ok=True)
+        return
+    for src in package_dirs:
+        target = bundle_root / "experience_compiler" / src.parent.name
+        shutil.copytree(src, target, dirs_exist_ok=True)
+
+
+def _copy_loop_review_outputs(release_root: Path, bundle_root: Path) -> None:
+    package_dirs = sorted(path for path in (release_root / "packages").glob("*/loops") if path.is_dir())
+    if not package_dirs:
+        return
+    if len(package_dirs) == 1:
+        shutil.copytree(package_dirs[0], bundle_root / "loops", dirs_exist_ok=True)
+        return
+    for src in package_dirs:
+        target = bundle_root / "loops" / src.parent.name
+        shutil.copytree(src, target, dirs_exist_ok=True)
+
+
 def is_unsafe_bundle_ref(ref: str) -> bool:
     path = Path(ref)
     return path.is_absolute() or ".." in path.parts
@@ -263,6 +317,8 @@ def _bundle_metadata_shape(bundle_root: Path, release_root: Path, settings: Sett
         "agent_apprentice_role": role,
         "expected_economic_value": task.get("expected_economic_value"),
         "expected_economic_value_for_agent_apprentice": task.get("expected_economic_value_for_agent_apprentice"),
+        "apprenticeship_mode": _session_apprenticeship_mode(session, settings),
+        "apprenticeship_mode_display": apprenticeship_mode_display(_session_apprenticeship_mode(session, settings)),
         "mentor_mode": _session_mentor_mode(session, settings),
         "task_status": task_status,
         "run_status": run_status,
@@ -280,9 +336,83 @@ def _write_manifest(bundle_root: Path, release_root: Path, settings: Settings, i
         manifest["status_reason"] = session["status_reason"]
     if include_internal_schema:
         manifest["source_release_schema_version"] = release_manifest.get("schema_version")
+    manifest.update(_tdo_manifest_shape(release_root))
+    manifest.update(_loop_manifest_shape(release_root))
     write_json(bundle_root / "contribution_manifest.json", manifest)
 
 
+def _loop_manifest_shape(release_root: Path) -> dict[str, Any]:
+    summary = summarize_loop_reviews(release_root)
+    return {
+        "has_loop_review_packets": summary.get("has_loop_review_packets"),
+        "loop_iteration_count": summary.get("loop_iteration_count"),
+        "loop_reviewer_types": summary.get("reviewer_types") or [],
+        "final_loop_verdict": summary.get("final_loop_verdict"),
+        "loop_review_refs": summary.get("loop_review_refs") or [],
+    }
+
+
+def _tdo_manifest_shape(release_root: Path) -> dict[str, Any]:
+    reports = []
+    for path in sorted((release_root / "packages").glob("*/tdo/tdo_report.json")):
+        try:
+            reports.append(read_json(path))
+        except Exception:
+            continue
+    if not reports:
+        return {
+            "tdo_enabled": False,
+            "tdo_status": "not_run",
+            "tdo_output_refs": [],
+            "experience_compiler_enabled": False,
+            "experience_compiler_status": "not_run",
+            "experience_compiler_output_refs": [],
+        }
+    latest = reports[-1]
+    output_refs: list[str] = []
+    package_tdo_dirs = sorted(path for path in (release_root / "packages").glob("*/tdo") if path.is_dir())
+    if len(package_tdo_dirs) == 1:
+        for child in sorted(package_tdo_dirs[0].iterdir()):
+            if child.is_file():
+                output_refs.append(f"tdo/{child.name}")
+    else:
+        for src in package_tdo_dirs:
+            for child in sorted(src.iterdir()):
+                if child.is_file():
+                    output_refs.append(f"tdo/{src.parent.name}/{child.name}")
+    fields = tdo_manifest_fields_from_report(latest)
+    fields["tdo_output_refs"] = output_refs
+    fields.update(_experience_compiler_manifest_shape(release_root, latest))
+    if len(reports) > 1:
+        fields["tdo_package_count"] = len(reports)
+    return fields
+
+
+def _experience_compiler_manifest_shape(release_root: Path, latest_report: dict[str, Any]) -> dict[str, Any]:
+    compiler_dirs = sorted(path for path in (release_root / "packages").glob("*/experience_compiler") if path.is_dir())
+    refs: list[str] = []
+    if len(compiler_dirs) == 1:
+        for child in sorted(compiler_dirs[0].rglob("*")):
+            if child.is_file():
+                refs.append(f"experience_compiler/{child.relative_to(compiler_dirs[0]).as_posix()}")
+    else:
+        for src in compiler_dirs:
+            for child in sorted(src.rglob("*")):
+                if child.is_file():
+                    refs.append(f"experience_compiler/{src.parent.name}/{child.relative_to(src).as_posix()}")
+    return {
+        "experience_compiler_enabled": bool(compiler_dirs),
+        "experience_compiler_status": latest_report.get("tdo_status"),
+        "experience_compiler_id": str(latest_report.get("tdo_id") or "").replace("tdo_", "compiler_", 1),
+        "experience_compiler_output_refs": refs,
+        "experience_compiler_rows_by_type": latest_report.get("rows_accepted_by_type") or {},
+        "experience_compiler_rounds_run": latest_report.get("rounds_run"),
+        "experience_compiler_average_quality_score": latest_report.get("average_quality_score"),
+        "experience_compiler_average_reuse_value_score": latest_report.get("average_reuse_value_score"),
+        "experience_compiler_judge_source": latest_report.get("tdo_judge_source"),
+    }
+
+
 def create_contribution_bundle(
     run_root: Path,
     bundle_root: Path | None = None,