agent-apprenticeship 0.1.5 → 0.1.7

package/README.md

@@ -1,5 +1,3 @@
-# Agent Apprenticeship
-
 The living ecosystem where AI agents learn from real-world work through iterative workflow loops, reusable experience, and collective training signal exchange.
 
 As agents move into long-horizon, economically valuable work, Agent Apprenticeship creates the open infrastructure where real-world tasks generate reusable learning signals and complex workflows advance through agent loops that turn execution into shared improvement.
@@ -11,198 +9,3 @@ Agent Apprenticeship is built for iterative workflow loops across domains, from
 Agent Apprenticeship is now available for anyone to start using with local agents including Codex, Cursor, Claude Code, OpenClaw, OpenCode, Hermes Agent, and custom agents, alongside different model providers. Users can run automated agent workflow loops locally, contribute agent learning signals back to the ecosystem, and use shared ecosystem signals to improve their own agents.
 
 Agent Apprenticeship is about the future of work and the economic value of agents. For every task executed through Agent Apprenticeship, the system can estimate task-level economic value, especially across specialized domains. It is built for everyday use to improve agent performance and outcome quality, while enabling users to exchange agent work experience with each other and with domain-expert-led agents in one living ecosystem.
-
-## Install
-
-```bash
-npx agent-apprenticeship init
-```
-
-```bash
-npm install -g agent-apprenticeship
-apprentice init
-```
-
-The installed command is:
-
-```bash
-apprentice
-```
-
-The long-form command also remains available:
-
-```bash
-agent-apprenticeship
-```
-
-## Quickstart
-
-```bash
-apprentice init
-apprentice settings
-apprentice run "Create a short market map for AI procurement tools."
-```
-
-Runs print the artifacts path and Contribution Bundle path.
-
-```bash
-apprentice ecosystem contribute <bundle_path>
-```
-
-Public ecosystem:
-
-https://github.com/Forsy-AI/agent-apprenticeship
-
-## Apprentice Agents
-
-Selected v0 Apprentice Agents:
-
-* Codex
-* Cursor
-* Claude Code
-* OpenClaw
-* OpenCode
-* Hermes Agent
-* Custom
-
-Agent Apprenticeship auto-detects installed CLIs. If multiple are detected, choose one during setup.
-
-Custom lets you provide a command template:
-
-```bash
-apprentice configure agent custom --command-template "my-agent run --workspace {workspace} --prompt-file {prompt_file}"
-```
-
-## Mentor Model Providers
-
-Store local keys in:
-
-```text
-~/.agent-apprenticeship/.env.local
-```
-
-Example:
-
-```bash
-OPENAI_API_KEY=""
-ANTHROPIC_API_KEY=""
-GEMINI_API_KEY=""
-OPENROUTER_API_KEY=""
-```
-
-Configure:
-
-```bash
-apprentice configure model
-apprentice doctor
-```
-
-## Mentor Modes
-
-```bash
-apprentice run "..." --mentor-mode model-assisted
-apprentice run "..." --mentor-mode expert-led
-apprentice run "..." --mentor-mode hybrid
-```
-
-* `model-assisted`: Mentor Model Provider handles the mentor loop.
-* `expert-led`: human expert checkpoints guide the mentor loop.
-* `hybrid`: Mentor Model Provider drafts and human expert checkpoints approve or edit.
-
-## Seed Dataset
-
-The seed dataset is included under:
-
-```text
-seed_dataset/
-```
-
-Explore seed tasks:
-
-```bash
-apprentice ecosystem list
-apprentice ecosystem search cloud
-apprentice ecosystem inspect aa-seed-task-501
-apprentice ecosystem pull aa-seed-task-501
-```
-
-## Ecosystem Learning
-
-Create Experience Packs from ecosystem experience:
-
-```bash
-apprentice learn create aa-seed-task-501
-apprentice learn preview <pack_id>
-apprentice learn replay <pack_id>
-apprentice learn keep <pack_id>
-apprentice run "Create a related incident response checklist." --experience-pack <pack_id>
-apprentice learn revert <pack_id>
-```
-
-Use active packs explicitly:
-
-```bash
-apprentice run "..." --use-active-experience-packs
-apprentice run "..." --no-experience-packs
-```
-
-## Contribution Bundles
-
-Runs produce Contribution Bundles.
-
-Contribute one to the public ecosystem:
-
-```bash
-apprentice ecosystem contribute <bundle_path>
-apprentice bundle contribute <bundle_path>
-```
-
-Public ecosystem:
-
-https://github.com/Forsy-AI/agent-apprenticeship
-
-## Ecosystem Auto-Share
-
-Default mode is Manual.
-
-```bash
-apprentice ecosystem configure --repo Forsy-AI/agent-apprenticeship
-apprentice ecosystem configure --auto-share manual
-apprentice ecosystem configure --auto-share ask
-apprentice ecosystem configure --auto-share automatic
-apprentice ecosystem status
-```
-
-Requirements:
-
-* GitHub CLI installed
-* `gh` authenticated
-* ecosystem repo configured
-
-## Search, Inspect, Pull
-
-Discover and export ecosystem experience:
-
-```bash
-apprentice ecosystem search <query>
-apprentice ecosystem inspect <id>
-apprentice ecosystem pull <id>
-```
-
-## Public Repo Structure
-
-```text
-seed_dataset/
-ecosystem/
-ecosystem/contributions/
-schemas/
-examples/
-```
-
-## Development Commands
-
-```bash
-.venv/bin/python -m pytest -q tests
-PYTHONPATH=src .venv/bin/python -m compileall -q src tests scripts examples
-bash scripts/export_public_repo.sh
-```

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.5",
+  "version": "0.1.7",
   "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.5"
+version = "0.1.7"
 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.5"
+__version__ = "0.1.7"

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)
     )