---
name: run-evidence-normalizer
description: Normalize one bounded run result into one structured evidence bundle for one selected package slice. Use after execution artifacts exist and before reconcile review. Do not use for package authoring, package readiness review, compile-only work, or final reconcile classification.
---

# Run Evidence Normalizer

## Purpose

Produce exactly one normalized **evidence bundle**
for exactly one executed **package slice**.

This is a **review and normalization skill**.
It MUST NOT silently edit package source files.
It closes only the evidence stage and emits the evidence-stage handoff.

## Read First

1. [references/EXECUTION_CONTRACT_SUMMARY.md](references/EXECUTION_CONTRACT_SUMMARY.md)
2. [assets/evidence.result.json](assets/evidence.result.json)
3. [assets/evidence-checklist.md](assets/evidence-checklist.md)

## Use This Skill When

- one execution attempt already happened
- raw run outputs already exist
- the package and selected slice are already known
- the next output must be one normalized evidence bundle for reconcile review

## Do Not Use This Skill When

- no run happened yet
- the main job is to compile a manual execution contract
- the main job is to classify the final reconcile outcome
- the main job is package authoring or package readiness review

## Hard Input Contract

Required inputs:

- `package_path`
- `slice_id`
- `run_input_root`

Optional inputs:

- `execution_plan_path`
- `output_path`
- `output_handoff_path`

The following evidence facts MUST be derivable from the selected slice,
the run root, the execution plan when present:

- `feature_id`
- `package_ref`
- `slice_id`
- `req_ids`
- `task_ids`
- `eval_ids`
- `produced_artifacts`
- verification results
- changed paths
- run status
- failure summary when applicable

If required evidence facts are missing or ambiguous,
STOP and return a concise `INPUT_GAP_REPORT`
instead of writing partial evidence output.

## Minimal Reading Guide

Read at minimum:

- `package.yaml`
- `slices.yaml`
- `requirements.yaml`
- `tasks.md`
- `evals.yaml`
- `execution.plan.yaml` when present
- raw run outputs under `run_input_root`

Normalize what happened.
Do not classify what should happen next.

## Output Contract

Write:

- one `evidence.result.json`
- one `handoff.packet.yaml` for the **execution-and-evidence** stage

Default paths:

- `${output_path:-./evidence.result.json}`
- `${output_handoff_path:-./handoff.packet.yaml}`

This evidence-stage handoff does not replace reconcile review.
It only closes normalization of one bounded run result.

## Normalization Rules

- Normalize exactly one run outcome for exactly one slice.
- Preserve source ids from package truth.
- Preserve raw failure state when the run failed.
- Distinguish `missing evidence` from `negative evidence`.
- `verification_results` MUST stay linked to `eval_ids`.
- `changed_paths` MUST stay bounded to observed run output.
- `produced_artifacts` SHOULD be path-like or URI-like references, not prose summaries.
- Do not classify `accepted | patch-required | relaunch | hold` here.
- Do not mutate package metadata here.

## Read Paths

- `${package_path}/package.yaml`
- `${package_path}/slices.yaml`
- `${package_path}/requirements.yaml`
- `${package_path}/tasks.md`
- `${package_path}/evals.yaml`
- `${execution_plan_path}` when provided
- `${run_input_root}/**`

## Write Paths

- `${output_path:-./evidence.result.json}`
- `${output_handoff_path:-./handoff.packet.yaml}`

## Workflow

1. Read package truth and selected slice.
2. Read execution plan when available.
3. Read raw run outputs, logs, diffs, and verification results.
4. Normalize all evidence into one bounded bundle.
5. Write `evidence.result.json`.
6. Write evidence-stage `handoff.packet.yaml`.
7. Stop if source ids cannot be preserved or evidence cannot be bounded to the selected slice.

## Stop Conditions

Stop and return a blocker report if:

- package or slice cannot be resolved
- run root is empty or unreadable
- produced artifacts cannot be linked to the selected slice
- verification results cannot be mapped to eval ids
- evidence would require invented success or failure claims

## Final Rule

This skill records what happened in normalized form.
It does not decide whether source truth should be accepted, patched, relaunched, or held.