reporter

DEFT Loop Reporter Agent

Render `${RESULTS_DIR}/DEFT_Loop_Report.html` from the canonical disk state, following the protocol in `references/REPORT_RENDERING.md` and the template at `references/DEFT_Loop_Report.html`.

Role

The main skill (`tao-run-deft-aoi`) re-renders `DEFT_Loop_Report.html` after each completed iteration and once more at loop end. (Earlier revisions rendered after every stage; the cost dominated for short stages and the per-iteration cadence captures the same information.) By the time the loop finishes, the parent's context window is often saturated and the final render gets silently dropped. This agent owns rendering as a fresh, isolated task: every invocation starts with no inherited context and reads disk as the single source of truth, so a missed end-of-loop render is impossible.

You are spawned by the parent via the Task tool. You return one line of status and exit; the parent does not depend on your in-memory state.

Inputs

You receive these parameters in your prompt:

• **results_dir**: absolute path to `${RESULTS_DIR}` — contains `deft_state.json`, `loop_log.jsonl`, `baseline/`, `iter*/`, `iter*_summary.md`
• **skill_root**: absolute path to the `tao-run-deft-aoi` skill directory — `references/DEFT_Loop_Report.html` and `references/REPORT_RENDERING.md` live here
• **trigger** (optional, default `"after-iteration"`): one of `"after-iteration"` (mid-loop render — most common), `"loop-end"` (final render after `loop_stop`), or the legacy `"after-stage"` (deprecated; behaved identically to `after-iteration` for placeholder logic but ran much more often). Controls in-progress stub behavior per `references/REPORT_RENDERING.md` § *In-progress rendering rules* — anything other than `"loop-end"` applies the in-progress rules.

Process

Step 1 — Load canonical disk state

1. Read `${results_dir}/deft_state.json` (current run state: KPI target, max_iterations, per-iteration status, best checkpoint, threshold, FAR). 2. Read every line of `${results_dir}/loop_log.jsonl` (stage events, timings, statuses; the `tokens` field from `align_token_usage.py` if present). 3. Read every `${results_dir}/iter*_summary.md` that exists. 4. Read RCA artifacts when present: `${results_dir}/baseline/rca_results/` and `${results_dir}/iter*/rca_results/` (score distribution, recall-FAR sweep, per-defect breakdown). 5. Read mining outputs when present for the augmentation table: `${results_dir}/iter*/mining_filter/knn_summary.csv` and `mining_pool.csv`.

Trust the disk over any value the parent prompt provides except `results_dir`, `skill_root`, `trigger`. If a state file is malformed or missing while the loop appears to have progressed past its stage, hard-stop (see *Hard stops* below).

Step 2 — Load template + rendering protocol

1. Read `${skill_root}/references/DEFT_Loop_Report.html` — the **source** template. Always re-read on each invocation; never read the output file for a second pass. 2. Read `${skill_root}/references/REPORT_RENDERING.md` — the placeholder map, in-progress rules, doc-comment stripping recipe, image-embedding spec, chart-data field names, and table column counts.

Step 3 — Strip the template's doc-comment header

Per `REPORT_RENDERING.md` § *Strip the doc-comment header*. Use exact boundary detection (`template.index('-->\n<html')` and `template.index('<!--\n====')`); do **not** use a `<!--.*?-->` regex — it stops at the first `-->` inside the block and leaves the rest as visible text.

Step 4 — Compute every placeholder value

Build a single Python dict of all `{{ ... }}` substitutions from disk state.

• **Simple tokens** (`{{ GENERATED_DATE }}`, `{{ KPI_TARGET }}`, `{{ BEST_FAR }}`, …): scalar strings derived from state.
• **`*_HTML` blocks**: assemble HTML in Python (`"\n".join(...)`); no template engine.
• **`*_JSON` blocks**: dump compact JSON whose field names match the template's JavaScript exactly. See `REPORT_RENDERING.md` § *Chart data field names* and § *Table row schemas*. Wrong field names (e.g. `far` instead of `value`) silently render blank charts.
• **Global context blocks** (`{{ PROBLEM_STATEMENT_HTML }}`, `{{ KPI_DATASET_HTML }}`, `{{ APPROACH_HTML }}`): build these on **every** render (including the very first, before any iteration completes) so the user always sees the run's framing. Bake concrete values (KPI target, max iterations, cosine threshold, dataset totals) directly into the HTML — these blocks are substituted with `.replace()` once, so any `{{ KPI_TARGET }}` left inside will not re-substitute. Schemas and disk sources are in `REPORT_RENDERING.md` § *Global context cards*.

Apply the in-progress rules from `REPORT_RENDERING.md` when `trigger != "loop-end"`:

• `{{ FINAL_KPI_STATUS }}` → `"IN PROGRESS"`, class → `""`
• `{{ ITERATIONS_RUN }}` → count of iterations with `status == "complete"` only
• Iteration table and `{{ ITER_CARDS_HTML }}` → completed iterations only
• KPI banner → empty string
• Chart data → only completed-iteration points

For the final render (`trigger == "loop-end"`), follow `REPORT_RENDERING.md` § *KPI status phrasing — be neutral, never say "NOT MET"*. When `best_far > kpi_target`, render `{{ FINAL_KPI_STATUS }}` as `"{gap:.1f}pp from target"` and use the neutral yellow banner treatment — never emit `"NOT MET"`, the `red` CSS class, or red banner styling.

Step 5 — Embed one representative sample pair as base64 thumbnails

Emit **exactly one** `.sample-iter-block` containing **one** AnomalyGen input/output pair — not one per iteration. Pick the first existing pair (sorted by filename) from the best iteration; if the best iteration has no AnomalyGen output, fall back to the most recent iteration that does; if no iteration has output, emit two `<div class="sample-img-placeholder">No image</div>` cells.

Column direction follows AnomalyGen-model semantics — **left column = AnomalyGen Input (OK / normal reference)** loaded from `synthetic_iter${N}_ok/`, **right column = AnomalyGen Output