agent-apprenticeship 0.2.0 → 0.3.0

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/progress.py

@@ -6,7 +6,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Callable, Literal
 
-from .io import append_jsonl, read_json, read_jsonl, write_json
+from .io import append_jsonl, read_workflow_json as read_json, read_workflow_jsonl as read_jsonl, write_json
 
 RUN_TERMINAL_STATUSES = {"completed", "partial", "failed"}
 

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/public_run.py

@@ -10,7 +10,7 @@ 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 .io import read_workflow_json as 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

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/public_sanitizer.py

@@ -3,9 +3,9 @@ import hashlib, json, re, shutil
 from pathlib import Path
 from typing import Any
 from .env import redact_secrets, contains_secret
-from .io import read_jsonl, append_jsonl, write_json
+from .io import read_workflow_jsonl as read_jsonl, append_jsonl, write_json
 
-PROMPT_TEMPLATE_ID='agent_apprenticeship_trace_worker_v0'
+PROMPT_TEMPLATE_ID='agent_apprenticeship_worker_v0'
 PROMPT_TEMPLATE_VERSION='0.1'
 PROMPT_PUBLICATION_STATUS='template_available_in_codebase'
 RAW_LOG_NAMES=set()

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/release_exporter.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 import shutil
 from pathlib import Path
-from .io import read_json, write_json, append_jsonl, read_jsonl
+from .io import read_workflow_json as read_json, write_json, append_jsonl, read_workflow_jsonl as read_jsonl
 from .public_sanitizer import create_public_release
 from .package_exporter import IGNORED_RELEASE_DIR_NAMES, is_ignored_release_path, public_task_record
 from .trace_normalizer import normalize_trace_for_export
+from .atif import to_workflow
 
 RELEASE_FILES=['full_task_records.jsonl','tasks.jsonl','task_intake_specs.jsonl','rubrics.jsonl','rubric_items.jsonl','raw_agent_traces.jsonl','agent_traces.jsonl','trace_normalization_reports.jsonl','actual_outputs_normalization_reports.jsonl','actual_outputs.jsonl','grader_results.jsonl','verifier_results.jsonl','evaluator_feedback.jsonl','revision_plans.jsonl','hillclimb_results.jsonl','lessons.jsonl','training_signals.jsonl','process_supervision.jsonl','reward_modeling.jsonl','verifier_training.jsonl','revision_preference_pairs.jsonl','role_results_index.jsonl','artifacts_index.json','packages_index.jsonl','forsy_like_collections.jsonl']
 
@@ -141,7 +142,7 @@ def _propagate_release_status_fields(release_root):
             _write_jsonl(path, rows)
 
     # Do not inject task_status into agent_traces.jsonl here.
-    # Trace rows are governed by the AgentTrace schema; attempt_status belongs
+    # Trace rows are governed by the WorkflowTrace schema; attempt_status belongs
     # there, but task_status is task/package-level metadata and is exported via
     # tasks.jsonl and packages_index.jsonl.
 
@@ -190,14 +191,14 @@ def create_release(run_root: Path, release_root: Path) -> Path:
             if norm is not None:
                 normalized_trace_count += 1; normalized_trace_step_count += len(norm.get('steps') or [])
             if tr is not None:
-                tr_row=normalize_trace_for_export(dict(tr), report)
+                tr_row=to_workflow(normalize_trace_for_export(dict(tr), report))
                 attempt_statuses.append(tr_row.get('attempt_status'))
                 tr_row['iteration_index']=0 if a == 'baseline' else 1
                 tr_row['previous_attempt_id']=None if a == 'baseline' else manifest.get('baseline_attempt_id')
                 tr_row['revision_group_id']=tid
                 tr_row['completion_reason']=manifest.get('loop_stop_reason')
                 append_jsonl(release_root/'agent_traces.jsonl', tr_row)
-                append_jsonl(release_root/'forsy_like_collections.jsonl', {'collection_id': tr.get('collection_id') or tid, 'trace_id': tr.get('trace_id'), 'attempt_kind': a, 'iteration_index': tr_row['iteration_index'], 'previous_attempt_id': tr_row['previous_attempt_id'], 'steps': tr.get('steps', []), 'trace_ref': f'packages/{tid}/attempts/{a}/agent_trace.json'})
+                append_jsonl(release_root/'forsy_like_collections.jsonl', {'collection_id': tr.get('collection_id') or tid, 'trace_id': tr.get('trace_id'), 'attempt_kind': a, 'iteration_index': tr_row['iteration_index'], 'previous_attempt_id': tr_row['previous_attempt_id'], 'trajectory': normalize_trace_for_export(tr, report), 'trace_ref': f'packages/{tid}/attempts/{a}/agent_trace.json'})
             else:
                 missing_traces += 1; blockers.append(f'missing attempts/{a}/agent_trace.json')
             attempt_trace_refs[a]={'raw': f'packages/{tid}/attempts/{a}/agent_trace.raw.json' if (pkg/f'attempts/{a}/agent_trace.raw.json').exists() else None, 'normalized': f'packages/{tid}/attempts/{a}/agent_trace.normalized.json' if (pkg/f'attempts/{a}/agent_trace.normalized.json').exists() else None, 'canonical': f'packages/{tid}/attempts/{a}/agent_trace.json' if (pkg/f'attempts/{a}/agent_trace.json').exists() else None, 'normalization_report': f'packages/{tid}/attempts/{a}/trace_normalization_report.json' if (pkg/f'attempts/{a}/trace_normalization_report.json').exists() else None}
@@ -256,4 +257,6 @@ def create_release(run_root: Path, release_root: Path) -> Path:
     except Exception:
         pass
     _propagate_release_status_fields(release_root)
+    from .agent_env_exporter import export_agent_env
+    export_agent_env(release_root)
     return release_root

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/rubric_generation.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from pydantic import BaseModel
 from .schemas import TaskIntakeSpec, RubricItem, RubricSpec, RubricQualityReport
 from .config import apprentice_agent_display_name, get_settings
-from .io import read_json
+from .io import read_workflow_json as read_json
 from .openai_structured import get_model_provider_status, run_structured_role
 from .public_sanitizer import sanitize_public_obj, sha256_text
 

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/schemas.py

@@ -102,7 +102,7 @@ class ActualOutputs(StrictModel):
     error_message: str | None = None
     metadata_json: DictAny = Field(default_factory=dict)
 
-class AgentTraceStep(StrictModel):
+class WorkflowTraceStep(StrictModel):
     step: int
     turn: int
     actor: str
@@ -393,8 +393,18 @@ class AgentTraceStep(StrictModel):
             raise ValueError("operation is required for non-user steps")
         return self
 
-class AgentTrace(StrictModel):
-    schema_version: str = "aa-trace-v0.1"
+class WorkflowTrace(StrictModel):
+    """Internal task/evaluation projection. Persist using ATIF I/O only."""
+
+    @model_validator(mode="before")
+    @classmethod
+    def from_atif(cls, value):
+        from .atif import to_workflow
+        if isinstance(value, dict) and "agent" in value and "steps" in value:
+            return to_workflow(value)
+        return value
+
+    schema_version: str = "ATIF-v1.8"
     trace_id: str
     collection_id: str | None = None
     run_id: str | None = None
@@ -425,7 +435,7 @@ class AgentTrace(StrictModel):
     final_output_summary: str | None = None
     learning: str | None = None
     termination_reason: Literal["task_complete","verifier_passed","verifier_failed","max_iterations_reached","agent_blocked","timeout","error_unrecoverable","partial_then_stopped","provider_usage_limit","other"]
-    steps: list[AgentTraceStep]
+    steps: list[WorkflowTraceStep]
     actual_outputs: ActualOutputs | None = None
     artifacts: list[ArtifactRef] = Field(default_factory=list)
     iteration_index: int | None = None
@@ -646,3 +656,6 @@ class TDOReport(StrictModel):
     generation_notes: list[str] = Field(default_factory=list)
     recommended_uses: list[str] = Field(default_factory=list)
     metadata_json: DictAny = Field(default_factory=dict)
+
+# Public trace models use the Harbor interchange contract.
+from .atif_models import Trajectory as AgentTrace, Step as AgentTraceStep

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/session_events.py

@@ -7,7 +7,7 @@ from typing import Any, Literal
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from .io import append_jsonl, read_jsonl
+from .io import append_jsonl, read_workflow_jsonl as read_jsonl
 
 
 SessionEventType = Literal[
@@ -84,9 +84,9 @@ def backfill_session_event_task_ids(run_root: Path, task_id: str | None) -> None
             changed = True
     if not changed:
         return
-    with path.open("w") as f:
-        for row in rows:
-            f.write(json.dumps(row, sort_keys=True) + "\n")
+    path.write_text("")
+    for row in rows:
+        append_jsonl(path, row)
 
 
 def next_followup_index(run_root: Path) -> int:

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/task_intake.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from pydantic import BaseModel
 from .schemas import RawTaskRecord, TaskIntakeSpec, TaskIntakeQualityReport
 from .config import apprentice_agent_display_name, get_settings
-from .io import read_json, write_json
+from .io import read_workflow_json as read_json, write_json
 from .openai_structured import extract_json_object, get_model_provider_status, run_structured_role
 from .public_sanitizer import sanitize_public_obj, sha256_text
 

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/tdo.py

@@ -14,7 +14,7 @@ from typing import Any
 
 from .config import Settings, apprentice_agent_display_name, configured_model_provider_ready
 from .env import contains_secret, redact_secrets
-from .io import append_jsonl, read_json, read_jsonl, write_json
+from .io import append_jsonl, read_workflow_json as read_json, read_workflow_jsonl as read_jsonl, write_json
 from .progress import ProgressCallback, append_progress_event
 from .public_sanitizer import sanitize_public_obj, sanitize_public_text
 from .schemas import TDOJudgeResult, TDOReport
@@ -3277,6 +3277,8 @@ def run_tdo_for_package(package_root: Path, settings: Settings, *, run_root: Pat
         )
         write_json(tdo_dir / "tdo_report.json", report)
         write_json(tdo_dir / "tdo_manifest.json", {"schema_version": TDO_VERSION, "tdo_status": "disabled"})
+        from .agent_env_exporter import export_agent_env
+        export_agent_env(package_root)
         return report.model_dump(mode="json")
     max_rounds = _int_env("AA_EXPERIENCE_COMPILER_MAX_ROUNDS", _int_env("AA_TDO_MAX_ROUNDS", 3))
     min_quality = _float_env("AA_EXPERIENCE_COMPILER_MIN_QUALITY", _float_env("AA_TDO_MIN_QUALITY_SCORE", 0.65))
@@ -3466,6 +3468,8 @@ def run_tdo_for_package(package_root: Path, settings: Settings, *, run_root: Pat
         write_artifacts_index(package_root)
     except Exception:
         pass
+    from .agent_env_exporter import export_agent_env
+    export_agent_env(package_root)
     return report.model_dump(mode="json")
 
 

package/src/agent_apprenticeship/trace_normalizer.py

@@ -0,0 +1,103 @@
+"""Validate inbound ATIF; never guess or repair an incompatible trace schema."""
+from __future__ import annotations
+from pathlib import Path
+from typing import Any
+from pydantic import BaseModel, Field
+from .schemas import ActualOutputs, WorkflowTrace
+from .atif import load_trace, to_workflow, from_workflow, validate_trace
+
+class TraceNormalizationContext(BaseModel):
+    task_id: str
+    attempt_id: str
+    attempt_kind: str
+    task: str
+    actual_outputs: ActualOutputs | None = None
+    trace_id_prefix: str = 'trace'
+
+class TraceNormalizationReport(BaseModel):
+    task_id: str
+    attempt_id: str
+    attempt_kind: str
+    raw_trace_ref: str | None = None
+    normalized_trace_ref: str | None = None
+    canonical_trace_ref: str | None = None
+    trace_schema_valid: bool = False
+    trace_normalized: bool = False
+    trace_lossless: bool = True
+    fallback_trace: bool = False
+    raw_step_count: int = 0
+    normalized_step_count: int = 0
+    discarded_step_count: int = 0
+    raw_trace_parse_error: bool = False
+    trace_normalization_error: bool = False
+    trace_normalization_partial: bool = False
+    validation_errors: list[str] = Field(default_factory=list)
+    warnings: list[str] = Field(default_factory=list)
+    field_mappings: dict[str,str] = Field(default_factory=dict)
+    input_dict_to_string_count: int = 0
+    output_dict_to_string_count: int = 0
+    causal_type_repair_count: int = 0
+    operation_repair_count: int = 0
+    action_repair_count: int = 0
+    metadata_json: dict[str, Any] = Field(default_factory=dict)
+
+class NormalizationResult(BaseModel):
+    normalized_trace: dict[str, Any] | None = None
+    report: TraceNormalizationReport
+    fallback_required: bool = False
+    parse_error: str | None = None
+
+
+def infer_attempt_status(trace: dict[str, Any], report: dict[str, Any] | None = None) -> str:
+    existing=trace.get('attempt_status')
+    if existing in {'completed', 'failed', 'blocked', 'fallback', 'partial'}:
+        return existing
+    termination=trace.get('termination_reason')
+    md=trace.get('metadata_json') if isinstance(trace.get('metadata_json'), dict) else {}
+    report=report or {}
+    if termination == 'task_complete':
+        return 'completed'
+    if termination == 'agent_blocked':
+        return 'blocked'
+    actual=trace.get('actual_outputs') if isinstance(trace.get('actual_outputs'), dict) else {}
+    if termination in {'timeout','error_unrecoverable','provider_usage_limit','verifier_failed'} or actual.get('status') in {'failed','timeout','error'}:
+        return 'failed'
+    if report.get('fallback_trace') or md.get('fallback_trace') or md.get('fallback_trace_created') or md.get('fallback_reason') or report.get('fallback_reason') or (isinstance(report.get('metadata_json'), dict) and report['metadata_json'].get('fallback_reason')):
+        return 'fallback'
+    steps=trace.get('steps') or []
+    if any(s.get('step_outcome') == 'blocked' for s in steps if isinstance(s, dict)):
+        return 'blocked'
+    if any(s.get('step_outcome') == 'failed' or s.get('success') is False for s in steps if isinstance(s, dict)):
+        return 'failed' if not any(s.get('success') is True for s in steps if isinstance(s, dict)) else 'partial'
+    if steps:
+        return 'partial'
+    return 'failed'
+
+def normalize_trace_for_export(trace: dict, report: dict | None = None) -> dict:
+    projection = to_workflow(trace) if "agent" in trace else dict(trace)
+    projection["attempt_status"] = infer_attempt_status(projection, report)
+    return from_workflow(projection)
+
+
+def repair_agent_trace_file(raw_trace_path: Path, context: TraceNormalizationContext) -> NormalizationResult:
+    report = TraceNormalizationReport(task_id=context.task_id, attempt_id=context.attempt_id,
+        attempt_kind=context.attempt_kind, raw_trace_ref=raw_trace_path.name)
+    try:
+        atif = load_trace(raw_trace_path)
+        trace = to_workflow(atif)
+        trace.update(task_id=context.task_id, attempt_id=context.attempt_id,
+                     attempt_kind=context.attempt_kind, task=context.task)
+        if context.actual_outputs is not None:
+            trace['actual_outputs'] = context.actual_outputs.model_dump(mode='json')
+        WorkflowTrace.model_validate(trace)
+        normalized = from_workflow(trace)
+    except (ValueError, TypeError, OSError) as error:
+        report.trace_normalization_error = True
+        report.trace_lossless = False
+        report.validation_errors.append(str(error))
+        return NormalizationResult(report=report, fallback_required=True, parse_error=str(error))
+    report.raw_step_count = report.normalized_step_count = len(atif['steps'])
+    report.trace_schema_valid = report.trace_normalized = True
+    report.normalized_trace_ref = 'agent_trace.normalized.json'
+    report.canonical_trace_ref = 'agent_trace.json'
+    return NormalizationResult(normalized_trace=normalized, report=report)

package/src/agent_apprenticeship/trace_prompt.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+TRACE_SCHEMA_GUIDANCE = """Write ./agent_trace.json as a complete Harbor ATIF v1.8 trajectory:
+{
+  "schema_version": "ATIF-v1.8",
+  "agent": {"name": "your-agent", "version": "your-agent-version"},
+  "steps": [
+    {"step_id": 1, "source": "user", "message": "Task instruction"},
+    {"step_id": 2, "source": "agent", "message": "Read task input",
+     "tool_calls": [{"tool_call_id": "call_2", "function_name": "read_file", "arguments": {"path": "input/task.md"}}],
+     "observation": {"results": [{"source_call_id": "call_2", "content": "Observed result"}]}}
+  ]
+}
+Use sequential integer step_id values starting at 1; source is system, user, or agent.
+Record each meaningful interaction faithfully. Tool results belong in observation.results,
+with source_call_id matching a tool_call_id on the same step. Preserve parallel calls.
+Record available timestamps, model_name, metrics, final_metrics and subagent_trajectories.
+Embedded subagents need unique trajectory_id values. References use trajectory_id or
+trajectory_path. Image/audio message parts use type and source {media_type, path};
+audio may include duration_sec. Never embed media bytes or invent results or metrics.
+Put project-specific task IDs, attempt IDs, artifacts, causal links, surface fields,
+and outcome evidence in extra.agent_apprenticeship at the root or step level.
+Do not add non-ATIF top-level fields. Do not include hidden chain-of-thought or secrets.
+Read inputs under ./input/ and write deliverables under ./artifacts/.
+Also write ./actual_outputs.json with task_id, attempt_id, attempt_kind, status,
+output_summary, primary_output_ref, deliverable_refs, artifact_refs and files_created.
+Use package-relative artifact references. Evaluation is performed separately.
+"""
+
+MASKING_GUIDANCE = """Sensitive info masking is standard for this run. Do not expose API keys, private tokens, credentials, or secrets in traces, logs, or artifacts. Preserve useful operational context while masking super-sensitive values."""
+
+
+def build_worker_prompt(
+    task_instruction: str,
+    rubric_md: str = "",
+    attempt_kind: str = "baseline",
+    input_files: list[str] | None = None,
+    deliverables: list[str] | None = None,
+    sensitive_info_masking: str = "standard",
+    workspace_path: str | None = None,
+) -> str:
+    input_files = input_files or []
+    deliverables = deliverables or []
+    input_section = "\n".join(f"- ./input/{name}" for name in input_files) or "- No explicit input files declared."
+    deliverable_section = "\n".join(f"- ./artifacts/{name}" for name in deliverables) or "- Write required task deliverables under ./artifacts/."
+    workspace_section = f"\nCurrent task workspace: {workspace_path}\n" if workspace_path else ""
+    masking_section = f"\n\n## Sensitive info masking\n{MASKING_GUIDANCE}" if sensitive_info_masking == "standard" else ""
+    return f"# Agent Apprenticeship Workflow Task\n\nAttempt: {attempt_kind}\n{workspace_section}\n{TRACE_SCHEMA_GUIDANCE}{masking_section}\n\n## Input files\n{input_section}\n\n## Required output contract\nYou must write these files in the current task workspace before finishing:\n- ./agent_trace.json\n- ./actual_outputs.json\n- ./artifacts/\n{deliverable_section}\n\nBefore finishing, verify ./agent_trace.json, ./actual_outputs.json, and ./artifacts/ exist. Do not only answer in chat/stdout. Do not say the task is complete unless those files exist.\n\n## Task\n{task_instruction}\n\n## Worker-visible evaluation rubric\n{rubric_md}\n\nFinal instruction: write the required files in this workspace, verify they exist, then stop.\n"

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/training_signals.py

@@ -11,7 +11,7 @@ def _current_evaluator_feedback_text(grader: GraderResult | None, evaluator: Eva
         return 'Evaluator feedback omitted because it referenced stale artifact-contract state.'
     return text
 
-def process_supervision_from_trace(trace: AgentTrace, grader: GraderResult | None=None, verifier: VerifierResult | None=None, evaluator: EvaluatorFeedback | None=None) -> list[ProcessSupervisionExample]:
+def process_supervision_from_trace(trace: WorkflowTrace, grader: GraderResult | None=None, verifier: VerifierResult | None=None, evaluator: EvaluatorFeedback | None=None) -> list[ProcessSupervisionExample]:
     final=grader.score if grader else None
     evaluator_text=_current_evaluator_feedback_text(grader, evaluator)
     out=[]

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/validation.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 import json
 from pathlib import Path
-from .schemas import AgentTrace
-from .io import read_jsonl
+from .schemas import WorkflowTrace
+from .io import read_workflow_jsonl as read_jsonl
 from .env import contains_secret
 from .public_sanitizer import has_prompt_leak
 from .artifact_resolver import artifact_ref_resolves, is_artifact_evidence_ref, normalize_artifact_ref
@@ -64,7 +64,7 @@ def validate_release(root: Path) -> dict[str, object]:
         counters['score_source_counts']=sc; counters['hillclimb_result_count']=len(read_jsonl(root/'hillclimb_results.jsonl')); counters['process_supervision_count']=len(read_jsonl(root/'process_supervision.jsonl')); counters['reward_modeling_count']=len(read_jsonl(root/'reward_modeling.jsonl')); counters['revision_preference_pair_count']=len(read_jsonl(root/'revision_preference_pairs.jsonl'))
         traces=read_jsonl(root/'agent_traces.jsonl'); counters['trace_count']=len(traces)
         for t in traces:
-            try: AgentTrace.model_validate(t); counters['trace_valid_count']+=1
+            try: WorkflowTrace.model_validate(t); counters['trace_valid_count']+=1
             except Exception: counters['trace_invalid_count']+=1; counters['release_valid']=False
             steps=t.get('steps') or []; counters['trace_step_count_total'] += len(steps)
             counters['trace_steps_with_tool_count'] += sum(1 for s in steps if s.get('tool'))

package/src/{agent_apprenticeship_trace → agent_apprenticeship}/verifier.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
+from .atif import from_workflow
 import json
 from pathlib import Path
-from .schemas import VerifierResult, GraderResult, ActualOutputs, AgentTrace
+from .schemas import VerifierResult, GraderResult, ActualOutputs, WorkflowTrace
 from .config import get_settings
-from .io import read_json
+from .io import read_workflow_json as read_json
 from .openai_structured import get_model_provider_status, run_structured_role
 from .public_sanitizer import sha256_text
 from .artifact_previews import build_artifact_previews
@@ -30,13 +31,13 @@ def deterministic_verify(grader: GraderResult, outputs: ActualOutputs) -> Verifi
         issues.append('hidden reference leakage')
     return VerifierResult(verifier_result_id=f'verifier_{outputs.attempt_id}', task_id=outputs.task_id, attempt_id=outputs.attempt_id, attempt_kind=outputs.attempt_kind, grader_result_id=grader.grader_result_id, verification_status='not_run', artifact_contract_ok=artifact_ok, evidence_grounding_ok=bool(grader.evidence_refs), score_consistency_ok=score_ok, hidden_reference_leaked=grader.hidden_reference_leaked, issues=issues, confidence=0.6, verifier_notes='Structural guardrail checked artifact refs, score bounds, and leakage flags only; Mentor verification did not run.', semantic_evidence_grounding_ok=None, unsupported_claims=[], leakage_check_ok=not grader.hidden_reference_leaked, model=None, provider=None, metadata_json={'score_source': grader.score_source, 'structural_guardrail': True, 'role_status': 'mentor_verifier_unavailable'})
 
-def _verifier_prompt(grader: GraderResult, outputs: ActualOutputs, trace: AgentTrace | None, artifact_preview_bundle: dict | None=None) -> str:
+def _verifier_prompt(grader: GraderResult, outputs: ActualOutputs, trace: WorkflowTrace | None, artifact_preview_bundle: dict | None=None) -> str:
     return """Return only valid JSON matching VerifierResult. Do not include markdown.
 Check whether the grader evidence is grounded in actual_outputs.json, artifact refs, trace evidence, and especially the artifact content previews. Check score consistency, unsupported claims, and hidden-reference leakage. Do not treat Apprentice Agent self-assessment or self evaluation as outcome evidence. Do not use deterministic fallback judgement; structural guardrails are package-integrity checks only and are not verifier judgments. Return exactly the VerifierResult schema fields. Do not add top-level fields not in schema. If you want to report extra checks such as reproducible, within_time_limit, uses_only_allowed_apis, passed_checks, or within_memory_limit, put them inside metadata_json.extra_model_fields.
 GraderResult JSON:
-""" + json.dumps(grader.model_dump(), sort_keys=True) + "\nActualOutputs JSON:\n" + json.dumps(outputs.model_dump(), sort_keys=True) + "\nArtifact content previews JSON:\n" + json.dumps(artifact_preview_bundle or {}, sort_keys=True)[:16000] + "\nTrace summary JSON:\n" + json.dumps((trace.model_dump() if trace else {}), sort_keys=True)[:12000]
+""" + json.dumps(grader.model_dump(), sort_keys=True) + "\nActualOutputs JSON:\n" + json.dumps(outputs.model_dump(), sort_keys=True) + "\nArtifact content previews JSON:\n" + json.dumps(artifact_preview_bundle or {}, sort_keys=True)[:16000] + "\nTrace summary JSON:\n" + json.dumps((from_workflow(trace.model_dump()) if trace else {}), sort_keys=True)
 
-def verify_attempt(grader: GraderResult, outputs: ActualOutputs, trace: AgentTrace | None=None, role_root: Path | None=None, package_root: Path | None=None) -> VerifierResult:
+def verify_attempt(grader: GraderResult, outputs: ActualOutputs, trace: WorkflowTrace | None=None, role_root: Path | None=None, package_root: Path | None=None) -> VerifierResult:
     settings=get_settings(); pre=deterministic_verify(grader, outputs); role_root=role_root or Path('outputs/roles')
     artifact_preview_bundle=build_artifact_previews(package_root, grader.evidence_refs or outputs.deliverable_refs or outputs.artifact_refs or outputs.files_created)
     if _model_verifier_active(settings) and settings.llm_verifier_enabled:

package/docs/bioactive_evidence_mapping_schema.md

@@ -1,113 +0,0 @@
-# Bioactive Evidence Mapping Extension Schema
-
-This optional Agent Apprenticeship schema describes evidence-mapping rows for specialized research and decision-support datasets. It is a general Experience Compilation extension and does not change the core product into a wellness-only tool.
-
-These rows are for provenance, uncertainty tracking, citation grounding, mechanism mapping, and verifier training. They are not medical advice, diagnosis, treatment guidance, cure claims, or sensitive personal records.
-
-## Row Families
-
-### evidence_mapping_sft_rows
-
-LoRA-ready instruction-tuning view for extracting grounded ingredient, compound, product, evidence, mechanism, safety/caution, and uncertainty fields from provided local source material.
-
-Required fields:
-
-- `row_id`
-- `schema_version`
-- `data_type`
-- `source_task_id`
-- `domain`
-- `subdomain`
-- `workflow_family`
-- `instruction`
-- `input_context`
-- `target_output`
-- `source_text_or_artifact_ref`
-- `source_evidence_ref_ids`
-- `quality_score`
-- `confidence`
-
-### ingredient_claim_verifier_rows
-
-Verifier-training view for checking whether a claim is supported by visible source evidence.
-
-Required fields:
-
-- `row_id`
-- `claim`
-- `ingredient_or_compound_entity`
-- `visible_evidence`
-- `expected_contract`
-- `verifier_decision`
-- `failure_reason`
-- `confidence`
-- `source_evidence_ref_ids`
-
-### product_ingredient_extraction_rows
-
-Extraction view for mapping product labels or specification tables into structured ingredient/product entities.
-
-Required fields:
-
-- `row_id`
-- `product_entity`
-- `ingredient_or_compound_entities`
-- `source_text_or_artifact_ref`
-- `extraction_contract`
-- `citation_or_provenance_refs`
-- `source_evidence_ref_ids`
-- `confidence`
-
-### mechanism_mapping_rows
-
-Mechanism evidence view for mapping a claim or source passage into a mechanism category with uncertainty.
-
-Required fields:
-
-- `row_id`
-- `ingredient_or_compound_entity`
-- `mechanism_category`
-- `evidence_summary`
-- `uncertainty`
-- `citation_or_provenance_refs`
-- `source_evidence_ref_ids`
-- `confidence`
-
-### safety_caution_rows
-
-Safety/caution evidence view for neutral flags and context constraints. Use abstract personal-context constraints only, never sensitive identity data.
-
-Required fields:
-
-- `row_id`
-- `ingredient_or_compound_entity`
-- `safety_caution_category`
-- `personal_context_constraints`
-- `evidence_summary`
-- `uncertainty`
-- `citation_or_provenance_refs`
-- `source_evidence_ref_ids`
-- `confidence`
-
-### citation_grounding_rows
-
-Grounding view for checking whether generated summaries cite visible evidence correctly.
-
-Required fields:
-
-- `row_id`
-- `generated_claim_or_summary`
-- `citation_or_provenance_refs`
-- `visible_evidence`
-- `verifier_decision`
-- `failure_reason`
-- `source_evidence_ref_ids`
-- `confidence`
-
-## Safety Rules
-
-- Use only provided local source material or package evidence refs.
-- Keep personal context as abstract constraints such as `pregnancy_context`, `medication_interaction_context`, or `allergy_context`; do not store identity or sensitive user details.
-- Record uncertainty and provenance for every extracted claim.
-- Do not infer treatment, cure, diagnosis, or patient-specific recommendations.
-- Do not mark unsupported claims as accepted verifier rows.