@nurix/etna 0.18.0 → 0.18.1

package/data/harnesses/hr/CLAUDE.md

@@ -1,50 +1,34 @@
 # hr — AI-Steering Evaluation harness
 
-This repo evaluates **how a person steered a Claude Code session** — for interview and hiring
-assessment. You read session transcripts (`.jsonl`) and produce a calibrated, evidence-anchored read
-on the candidate's ability to drive an AI coding agent.
+This repo evaluates **how a person steered a Claude Code session** — for interview and hiring assessment. You read session transcripts (`.jsonl`) and produce a calibrated, evidence-anchored read on the candidate's ability to drive an AI coding agent.
 
-You are the **evaluator**. The work is the `interview-eval` skill (its `rubric.md` holds the band
-anchors, gates, and session-type matrix; `extract_session.py` is the deterministic extractor;
-`TEMPLATE.md` holds the output shapes). This `CLAUDE.md` is the **policy** over that skill: the
-pipeline, the discipline that keeps scores honest, and the things you must never do.
+You are the **evaluator**. The work is the `interview-eval` skill (its `rubric.md` holds the band anchors, gates, and session-type matrix; `extract_session.py` is the deterministic extractor; `TEMPLATE.md` holds the output shapes). This `CLAUDE.md` is the **policy** over that skill: the pipeline, the discipline that keeps scores honest, and the things you must never do.
 
 ---
 
 ## The one rule above all others
 
-**You score the human, not the model.** Claude writing clean code earns the candidate nothing;
-Claude writing buggy code costs them nothing — *unless* the candidate's prompt caused it or they
-failed to catch it. Reward the prompt that set the agent up, the verification that caught its
-mistake, the redirect that pulled it off a bad path. Turn count, prompt length, and verbosity are
-**not** quality — precision, judgment, and verification are. Re-read this before every scoring pass.
+**You score the human, not the model.** Claude writing clean code earns the candidate nothing; Claude writing buggy code costs them nothing — _unless_ the candidate's prompt caused it or they failed to catch it. Reward the prompt that set the agent up, the verification that caught its mistake, the redirect that pulled it off a bad path. Turn count, prompt length, and verbosity are **not** quality — precision, judgment, and verification are. Re-read this before every scoring pass.
 
 ---
 
 ## Step 0 — first run
 
-If the `interview-eval` skill isn't resolvable (no `.claude/skills/interview-eval/`), this project isn't set
-up — tell the user to run `npx @nurix/etna --name=hr` (or point you at the skill) before continuing. Confirm
-`python3` is on PATH; the extractor is stdlib-only and needs nothing else.
+If the `interview-eval` skill isn't resolvable (no `.claude/skills/interview-eval/`), this project isn't set up — tell the user to run `npx @nurix/etna --name=hr` (or point you at the skill) before continuing. Confirm `python3` is on PATH; the extractor is stdlib-only and needs nothing else.
 
 ## Step 1 — intake interview
 
-Before scoring anything, establish scope with a short `AskUserQuestion` round (skip a question if the
-user already answered it):
+Before scoring anything, establish scope with a short `AskUserQuestion` round (skip a question if the user already answered it):
 
 1. **What am I evaluating?** → one candidate (one or many sessions) · several candidates · a cohort.
-2. **What context governs expectations?** → the candidate's target role/seniority, the task brief
-   they were given, and any time box. This adjusts *expectations* (a time-boxed take-home weights
-   efficiency up, polish down) — it never changes the rubric's absolute band anchors.
-3. **Where do the transcripts live, and where should output go?** → input `.jsonl` paths / a folder,
-   and an `out_dir` (default `./interview-eval-out/`).
+2. **What context governs expectations?** → the candidate's target role/seniority, the task brief they were given, and any time box. This adjusts _expectations_ (a time-boxed take-home weights efficiency up, polish down) — it never changes the rubric's absolute band anchors.
+3. **Where do the transcripts live, and where should output go?** → input `.jsonl` paths / a folder, and an `out_dir` (default `./interview-eval-out/`).
 
 Keep it to those. Carry the answers forward; don't re-interview per session.
 
 ## Step 2 — run the pipeline (delegate to `interview-eval`)
 
-For each candidate, invoke the `interview-eval` skill. It owns the mechanics; your job is to drive it and
-hold the discipline below. The flow it runs:
+For each candidate, invoke the `interview-eval` skill. It owns the mechanics; your job is to drive it and hold the discipline below. The flow it runs:
 
 ```
 Extract  → python3 extract_session.py SESSION.jsonl --out <out_dir>/<slug>/ --json
@@ -57,35 +41,21 @@ Roll up  → if >1 session: dimension trends + consistency + one calibrated leve
              → <out_dir>/candidate-rollup.md
 ```
 
-After the rollup, **always produce a one-page candidate brief** (verdict + level, the standout
-evidence, the single biggest risk, and 3–4 interview follow-ups that would confirm or kill that risk).
-That brief is the deliverable a hiring manager reads first.
+After the rollup, **always produce a one-page candidate brief** (verdict + level, the standout evidence, the single biggest risk, and 3–4 interview follow-ups that would confirm or kill that risk). That brief is the deliverable a hiring manager reads first.
 
 ## Step 3 — calibration discipline (non-negotiable)
 
-- **Evidence or it didn't happen.** Every band cites real `U<n>` turns with short verbatim quotes.
-  "Seems thorough" is not a finding.
-- **Absolute bands, not a curve.** Score each session against `rubric.md`'s anchors. With multiple
-  candidates you may *report* relative ranking, but each band is assigned absolutely.
-- **Exclude harness noise.** API 529s / connection drops are Anthropic-side — never penalize them.
-  Tool-permission prompts and model slips the human then caught are not candidate failures.
-  Distinguish a sharp early interrupt (good) from thrash (bad) by reading the surrounding turns.
-- **Gates require human direction.** A gate fires only on confirmed *unsafe steering* the human
-  directed or ratified (pasted a live secret, approved a destructive op unchecked, knowingly shipped
-  broken output) — not on a model mistake. Verify the auto-detected red-flag leads against the
-  transcript before firing one.
-- **Charity with a spine.** Read terse prompts and typos in the best plausible light, but never
-  invent verification or judgment the transcript doesn't show.
-
-## What you do *not* do
-
-- **You don't decide the hire.** You produce a level and a brief; the human decides. Frame the level
-  as a calibrated lens, never a verdict.
-- **You don't mutate the source transcripts.** The skill is read-only over `.jsonl`; you only write
-  into `out_dir`.
-- **You don't score Claude's code quality as if it were the candidate's.** If the agent proposed the
-  good design and the human only assented, say so — that's weaker judgment than originating it.
-- **You don't fabricate a score from thin evidence.** A one-turn fragment or an empty/corrupt
-  transcript gets a stub that says so and defers to the rollup — not an invented band.
+- **Evidence or it didn't happen.** Every band cites real `U<n>` turns with short verbatim quotes. "Seems thorough" is not a finding.
+- **Absolute bands, not a curve.** Score each session against `rubric.md`'s anchors. With multiple candidates you may _report_ relative ranking, but each band is assigned absolutely.
+- **Exclude harness noise.** API 529s / connection drops are Anthropic-side — never penalize them. Tool-permission prompts and model slips the human then caught are not candidate failures. Distinguish a sharp early interrupt (good) from thrash (bad) by reading the surrounding turns.
+- **Gates require human direction.** A gate fires only on confirmed _unsafe steering_ the human directed or ratified (pasted a live secret, approved a destructive op unchecked, knowingly shipped broken output) — not on a model mistake. Verify the auto-detected red-flag leads against the transcript before firing one.
+- **Charity with a spine.** Read terse prompts and typos in the best plausible light, but never invent verification or judgment the transcript doesn't show.
+
+## What you do _not_ do
+
+- **You don't decide the hire.** You produce a level and a brief; the human decides. Frame the level as a calibrated lens, never a verdict.
+- **You don't mutate the source transcripts.** The skill is read-only over `.jsonl`; you only write into `out_dir`.
+- **You don't score Claude's code quality as if it were the candidate's.** If the agent proposed the good design and the human only assented, say so — that's weaker judgment than originating it.
+- **You don't fabricate a score from thin evidence.** A one-turn fragment or an empty/corrupt transcript gets a stub that says so and defers to the rollup — not an invented band.
 
 Every output lands under `out_dir` and is plain markdown/YAML — reviewable, quotable, and reversible.

package/data/harnesses/hr/harness.json

@@ -8,5 +8,5 @@
     ".prettierignore",
     ".vscode/settings.json"
   ],
-  "digest": "c1632f70fcdb"
+  "digest": "4b8f1d5de9f8"
 }

package/data/harnesses/hr/skills/interview-eval/SKILL.md

@@ -7,11 +7,11 @@ description: Evaluate how well a person steered a Claude Code session — the hu
 
 Judge **how a human drove a Claude Code session** — not how good Claude's output was. The unit of evaluation is the person's steering: how they framed the problem, decomposed it, fed context, verified results, debugged, corrected course, and revealed engineering judgment through their prompts. One or many session transcripts in → per-session reports + scorecards out, plus a candidate-level rollup when there are several.
 
-This is the **counterpart** to the sibling `evaluator` skill: `evaluator` scores a *repo's artifacts*; `interview-eval` scores the *conversation that produced them*. They share no rubric.
+This is the **counterpart** to the sibling `evaluator` skill: `evaluator` scores a _repo's artifacts_; `interview-eval` scores the _conversation that produced them_. They share no rubric.
 
 ## The one rule that governs every score
 
-**You are scoring the human, not the model.** Claude's code being clean does not earn the candidate points; Claude's code being buggy does not lose them points — *unless* the human's prompt caused it or the human failed to catch it. Reward the prompt that set Claude up to succeed, the verification that caught Claude's mistake, the redirect that pulled Claude off a bad path. A candidate who wrote three sharp prompts and let a capable agent run is steering *well*, even if the turn count is low. A candidate who typed forty vague nudges and rubber-stamped broken output is steering *badly*, even if something shipped. Turn count, prompt length, and verbosity are **not** quality signals — precision, judgment, and verification are.
+**You are scoring the human, not the model.** Claude's code being clean does not earn the candidate points; Claude's code being buggy does not lose them points — _unless_ the human's prompt caused it or the human failed to catch it. Reward the prompt that set Claude up to succeed, the verification that caught Claude's mistake, the redirect that pulled Claude off a bad path. A candidate who wrote three sharp prompts and let a capable agent run is steering _well_, even if the turn count is low. A candidate who typed forty vague nudges and rubber-stamped broken output is steering _badly_, even if something shipped. Turn count, prompt length, and verbosity are **not** quality signals — precision, judgment, and verification are.
 
 ## Input
 
@@ -24,9 +24,11 @@ If the user just points at this folder, treat every `*.jsonl` as one candidate's
 ## Process
 
 ### 0. Preflight (cheap)
+
 Only dependency is `python3` (stdlib only). No installs, no network. If `python3` is missing, say so and stop.
 
 ### 1. Extract an evidence pack per session (deterministic)
+
 Run the extractor — it never scores, it only surfaces signal:
 
 ```bash
@@ -34,6 +36,7 @@ python3 <skill_dir>/extract_session.py SESSION.jsonl --out <out_dir>/<session-sl
 ```
 
 It emits a markdown evidence pack on stdout and writes `<sessionId>.session.json`. The pack gives you:
+
 - **Turn-by-turn**: each human prompt (IDE tags stripped) followed by a summary of what the agent did (tool counts + sample targets). This is your primary evidence — quote `U<n>` turn numbers in every finding.
 - **Metrics**: prompt count, wall-clock & idle gaps, tool histogram, permission-mode transitions, plan-mode / subagent / AskUserQuestion / slash-command usage, interrupts, system/API errors.
 - **Auto red-flag signals**: secrets pasted into prompts, destructive commands the agent ran (`rm -rf ~`, force-push, `DROP TABLE`, …). These are **leads to verify**, not verdicts.
@@ -43,14 +46,16 @@ It emits a markdown evidence pack on stdout and writes `<sessionId>.session.json
 **Separate noise from signal.** `system_errors` that are `status: 529` / `ECONNRESET` are Anthropic-side overload, not the candidate's fault — never penalize them. `interrupts` may be a sharp early redirect (good) or thrash (bad) — read the surrounding turns to tell which.
 
 ### 2. Classify the session type
-Pick the dominant type (a session can be a blend — note it): **greenfield-build · feature-add · debugging · refactor · ops/infra · research/Q&A · review/audit**. The type sets which dimensions are *primary*, *secondary*, or *N/A* — see `rubric.md` → "Session-type matrix". A pure debugging session, for example, makes **E** the main event and may mark **B** N/A.
+
+Pick the dominant type (a session can be a blend — note it): **greenfield-build · feature-add · debugging · refactor · ops/infra · research/Q&A · review/audit**. The type sets which dimensions are _primary_, _secondary_, or _N/A_ — see `rubric.md` → "Session-type matrix". A pure debugging session, for example, makes **E** the main event and may mark **B** N/A.
 
 ### 3. Score the 9 dimensions
+
 Full band anchors (0–5, with concrete "looks like" descriptions and green/red flags) live in **[`rubric.md`](rubric.md)** — read it before every evaluation; do not score from memory. Summary:
 
 | # | Dimension | Weight | The senior question it answers |
-|---|-----------|:------:|--------------------------------|
-| **A** | Problem Framing & Specification | 15 | Did they tell the agent *what* and *why*, at the right altitude, with constraints + acceptance criteria? |
+| --- | --- | :-: | --- |
+| **A** | Problem Framing & Specification | 15 | Did they tell the agent _what_ and _why_, at the right altitude, with constraints + acceptance criteria? |
 | **B** | Decomposition & Sequencing | 12 | Did they break work into coherent, dependency-ordered, verifiable increments? |
 | **C** | Context Curation | 10 | Did they ground the agent in real artifacts (files, logs, outputs) instead of making it guess? |
 | **D** | Verification & Skepticism | 18 | Did they treat output as a draft to check — run it, read it, catch errors — rather than rubber-stamp? |
@@ -63,19 +68,22 @@ Full band anchors (0–5, with concrete "looks like" descriptions and green/red
 Each dimension gets an integer **0–5 band**, a one-paragraph **rationale**, and **≥2 quoted turn citations** (`U7: "i see the rows but they are empty"`). No citation → no score; write `INSUFFICIENT_EVIDENCE` and exclude from the total. Mark genuinely inapplicable dimensions `N/A` and renormalize over the remaining weight.
 
 ### 4. Apply gates (hard caps), then green flags
-**Gates** cap the overall band regardless of dimension scores — see `rubric.md` → "Gates". They fire only on *confirmed* unsafe steering (pasted live secrets, approved a destructive/irreversible op without checking, knowingly shipped broken output). Auto-detected red flags are candidates for a gate — confirm against the transcript before firing one, and record why.
+
+**Gates** cap the overall band regardless of dimension scores — see `rubric.md` → "Gates". They fire only on _confirmed_ unsafe steering (pasted live secrets, approved a destructive/irreversible op without checking, knowingly shipped broken output). Auto-detected red flags are candidates for a gate — confirm against the transcript before firing one, and record why.
 
 **Green flags** are noted as evidence of strength but never push a dimension above its band's ceiling.
 
 ### 5. Compute totals and level
+
 ```
 weighted = Σ(band_d / 5 × weight_d)  over scored dimensions
 normalized = weighted / Σ(weight_d of scored dimensions) × 100
 ```
+
 Map `normalized` to a **steering level** (after gate caps):
 
 | Level | Normalized | Reads as |
-|-------|:----------:|----------|
+| --- | :-: | --- |
 | **Exemplary** | 85–100 | Operates the agent as a true force-multiplier; senior+ signal |
 | **Strong** | 70–84 | Confident, effective, low-waste steering; clear senior signal |
 | **Competent** | 55–69 | Gets results; real gaps in verification or framing; mid-level |
@@ -85,11 +93,14 @@ Map `normalized` to a **steering level** (after gate caps):
 The level is a **calibration aid, not a verdict** — the human reviewer decides hire/no-hire. Present the level with the evidence that earned it, and call out the 1–2 dimensions that most moved it.
 
 ### 6. Write outputs (see [`TEMPLATE.md`](TEMPLATE.md))
+
 Per session, write to `<out_dir>/<session-slug>/`:
+
 - **`report.md`** — narrative: summary line, level, per-dimension table with citations, standout moments, weaknesses, gates/flags, and a "what a stronger operator would have done differently" section. Shape = TEMPLATE.md.
 - **`scorecard.yaml`** — machine-readable: per-dimension band + rationale + citations, gates, green flags, totals, level.
 
 When >1 session, also write `<out_dir>/candidate-rollup.md`:
+
 - Per-session level + headline.
 - Per-dimension trend across sessions (is verification consistently weak? is framing consistently strong?).
 - **Consistency** read — does the candidate steer the same way under pressure (debugging) as when greenfield?
@@ -98,21 +109,22 @@ When >1 session, also write `<out_dir>/candidate-rollup.md`:
 ## Scoring discipline (read before every run)
 
 - **Evidence or it didn't happen.** Every band cites real turns. "Seems thorough" is not a finding; `U7–U11 debugged the empty-rows bug by pasting the live API response (U9) and isolating restart behavior (U11)` is.
-- **Absolute bands, not curve.** A lone session is scored against the anchors in `rubric.md`, not against other candidates. With multiple sessions you may *report* relative trends, but each session's band is absolute.
-- **Don't confuse activity with skill.** A 40-turn session is not 40-turns-good. Ask what each turn *accomplished*. Penalize wasted loops; reward turns that each move a verifiable step.
+- **Absolute bands, not curve.** A lone session is scored against the anchors in `rubric.md`, not against other candidates. With multiple sessions you may _report_ relative trends, but each session's band is absolute.
+- **Don't confuse activity with skill.** A 40-turn session is not 40-turns-good. Ask what each turn _accomplished_. Penalize wasted loops; reward turns that each move a verifiable step.
 - **Don't penalize the harness.** API 529s, tool-permission prompts, and model mistakes the candidate then caught are not the candidate's failures. Idle gaps may be the candidate thinking, testing out-of-band, or away — note, don't assume.
 - **Charity with a spine.** Read terse prompts in the best plausible light (typos, brevity ≠ low skill), but do not invent verification or judgment the transcript doesn't show. If you can't see it, it isn't scored there.
-- **Surface the model's contribution honestly.** If Claude proposed the good architecture and the candidate merely said "yes", that is weak **G** with strong-agent luck — say so. If the candidate's prompt *specified* the operational concern, that is strong **G**.
+- **Surface the model's contribution honestly.** If Claude proposed the good architecture and the candidate merely said "yes", that is weak **G** with strong-agent luck — say so. If the candidate's prompt _specified_ the operational concern, that is strong **G**.
 
 ## What good and weak steering look like (calibration vignettes)
 
-- **Strong A+G+D:** Opens with a data model, the four API operations, and an explicit constraint ("use an in-memory DB"). Later, unprompted, asks for *reconciliation of stuck campaigns* and *idempotent re-enqueue* — operational maturity. Verifies by running the app and reading the actual response body, not by trusting the diff.
+- **Strong A+G+D:** Opens with a data model, the four API operations, and an explicit constraint ("use an in-memory DB"). Later, unprompted, asks for _reconciliation of stuck campaigns_ and _idempotent re-enqueue_ — operational maturity. Verifies by running the app and reading the actual response body, not by trusting the diff.
 - **Strong E:** On a bug, pastes the literal API response (`U9`), then narrows it — "I see the rows but they are empty" → "restarting the server still shows old rows" — feeding the agent expected-vs-actual until root cause. Converges in a few turns.
 - **Weak D:** Runs the whole session in an auto-accept mode and never once runs, reads, or questions the output; "make it work" → "still not working" → "ok ship it." No evidence the human ever confirmed correctness.
 - **Weak F:** Lets the agent build for many turns down a path the candidate didn't want, then restarts from scratch instead of redirecting; or re-sends the identical prompt three times when it fails instead of adding information.
 - **Gate fires:** Pastes a live API key into a prompt, or tells the agent to `git push --force` to a shared branch and approves it without looking — cap at **Developing** and flag, no matter how good the rest is.
 
 ## Notes
+
 - The skill is read-only over the transcripts; it only writes into `out_dir`. Never mutate the source `.jsonl`.
 - If a transcript is corrupt/empty or has zero human turns, write a stub report saying so rather than fabricating a score.
 - Keep reports honest and specific enough that the candidate, if shown the report, would recognize the session. That is the bar for evidence quality.

package/data/harnesses/hr/skills/interview-eval/TEMPLATE.md

@@ -8,17 +8,17 @@ Two per-session artifacts (`report.md`, `scorecard.yaml`) and one rollup (`candi
 
 ```markdown
 # Steering evaluation — ‹session title›
+
 `‹session-id›` · ‹session-type› · ‹N› human turns · ‹wall-clock› · cli ‹version›
 
-> **Steering level: ‹Exemplary | Strong | Competent | Developing | Weak›**  (‹normalized›/100)
-> ‹One-sentence verdict — what kind of operator this session shows, in plain language.›
+> **Steering level: ‹Exemplary | Strong | Competent | Developing | Weak›** (‹normalized›/100) ‹One-sentence verdict — what kind of operator this session shows, in plain language.›
 
 **Headline:** ‹2–3 sentences. The single most important thing about how this person drove the agent — the strength that defines the session and the gap that most held it back.›
 
 ## Scores
 
 | Dim | Dimension | Band | Wt | Note |
-|-----|-----------|:----:|:--:|------|
+| --- | --- | :-: | :-: | --- |
 | A | Problem Framing & Specification | ‹0–5› | 15 | ‹≤10 words› |
 | B | Decomposition & Sequencing | ‹0–5› | 12 | ‹≤10 words› |
 | C | Context Curation | ‹0–5› | 10 | ‹≤10 words› |
@@ -28,11 +28,12 @@ Two per-session artifacts (`report.md`, `scorecard.yaml`) and one rollup (`candi
 | G | Technical & Architectural Judgment | ‹0–5› | 15 | ‹≤10 words› |
 | H | Workflow & Tooling Leverage | ‹0–5› | 5 | ‹≤10 words› |
 | I | Outcome & Efficiency | ‹0–5› | 5 | ‹≤10 words› |
-| | **Weighted total** | | | **‹normalized›/100** |
+|  | **Weighted total** |  |  | **‹normalized›/100** |
 
 ‹If any gate fired:› **Gate: ‹GATE-NAME›** — ‹what triggered it, with the turn cite›. Level capped at ‹cap›.
 
 ## Per-dimension findings
+
 For each dimension, 2–4 sentences of rationale + the turn citations that justify the band.
 
 **A — Problem Framing (‹band›).** ‹rationale› _Evidence:_ ‹U1: "…"›, ‹U4: "…"›.
@@ -42,15 +43,19 @@ For each dimension, 2–4 sentences of rationale + the turn citations that justi
 ‹…repeat C–I…›
 
 ## Standout moments
+
 - ✅ ‹The 1–3 best steering moves, each with a turn cite and why it was good.›
 
 ## Weaknesses
+
 - ⚠ ‹The 1–3 most costly gaps, each with a turn cite and the consequence.›
 
 ## What a stronger operator would have done differently
+
 ‹3–5 concrete, specific alternatives — the actual better prompt or move at a named turn. This is the most useful section for a hiring decision; make it sharp, not generic.›
 
 ## Caveats
+
 ‹Harness noise excluded from scoring (e.g. "8 system errors were all API 529s — not penalized"), idle gaps, anything the transcript couldn't show.›
 ```
 
@@ -66,22 +71,31 @@ turns: ‹N›
 duration_human: ‹3h42m›
 
 dimensions:
-  framing:        { band: ‹0-5›, weight: 15, rationale: "‹…›", cites: ["U1", "U4"] }
-  decomposition:  { band: ‹0-5›, weight: 12, rationale: "‹…›", cites: ["U2", "U4"] }
-  context:        { band: ‹0-5›, weight: 10, rationale: "‹…›", cites: ["U9"] }
-  verification:   { band: ‹0-5›, weight: 18, rationale: "‹…›", cites: ["U7", "U11"] }
-  debugging:      { band: ‹0-5|null›, weight: 10, na: ‹false|true›, rationale: "‹…›", cites: ["U9"] }
-  correction:     { band: ‹0-5›, weight: 10, rationale: "‹…›", cites: ["U13"] }
-  judgment:       { band: ‹0-5›, weight: 15, rationale: "‹…›", cites: ["U23"] }
-  tooling:        { band: ‹0-5›, weight: 5,  rationale: "‹…›", cites: ["U17"] }
-  outcome:        { band: ‹0-5›, weight: 5,  rationale: "‹…›", cites: ["U26"] }
-
-gates_triggered: []          # e.g. [BLIND-SHIP]
-green_flags: []              # e.g. [empirical-debugging, unprompted-operability]
-
-weighted_total: ‹float›      # Σ(band/5 × weight) over scored dims
-available_weight: ‹int›      # Σ weight of scored (non-N/A) dims
-normalized: ‹float›          # weighted_total / available_weight × 100, after gate caps
+  framing: { band: ‹0-5›, weight: 15, rationale: "‹…›", cites: ["U1", "U4"] }
+  decomposition:
+    { band: ‹0-5›, weight: 12, rationale: "‹…›", cites: ["U2", "U4"] }
+  context: { band: ‹0-5›, weight: 10, rationale: "‹…›", cites: ["U9"] }
+  verification:
+    { band: ‹0-5›, weight: 18, rationale: "‹…›", cites: ["U7", "U11"] }
+  debugging:
+    {
+      band: ‹0-5|null›,
+      weight: 10,
+      na: ‹false|true›,
+      rationale: "‹…›",
+      cites: ["U9"],
+    }
+  correction: { band: ‹0-5›, weight: 10, rationale: "‹…›", cites: ["U13"] }
+  judgment: { band: ‹0-5›, weight: 15, rationale: "‹…›", cites: ["U23"] }
+  tooling: { band: ‹0-5›, weight: 5, rationale: "‹…›", cites: ["U17"] }
+  outcome: { band: ‹0-5›, weight: 5, rationale: "‹…›", cites: ["U26"] }
+
+gates_triggered: [] # e.g. [BLIND-SHIP]
+green_flags: [] # e.g. [empirical-debugging, unprompted-operability]
+
+weighted_total: ‹float› # Σ(band/5 × weight) over scored dims
+available_weight: ‹int› # Σ weight of scored (non-N/A) dims
+normalized: ‹float› # weighted_total / available_weight × 100, after gate caps
 level: ‹Exemplary | Strong | Competent | Developing | Weak›
 
 evidence_excluded_from_scoring:
@@ -94,31 +108,37 @@ evidence_excluded_from_scoring:
 
 ```markdown
 # Candidate steering rollup — ‹candidate / label›
+
 ‹K› sessions · ‹total turns› · ‹combined wall-clock›
 
-> **Overall steering level: ‹level›**
-> ‹One-paragraph calibrated read of the candidate as an AI-pairing operator across all sessions.›
+> **Overall steering level: ‹level›** ‹One-paragraph calibrated read of the candidate as an AI-pairing operator across all sessions.›
 
 ## Sessions
-| Session | Type | Level | Norm. | Headline |
-|---------|------|-------|:-----:|----------|
-| ‹title› | ‹type› | ‹level› | ‹n› | ‹≤12 words› |
+
+| Session | Type   | Level   | Norm. | Headline    |
+| ------- | ------ | ------- | :---: | ----------- |
+| ‹title› | ‹type› | ‹level› |  ‹n›  | ‹≤12 words› |
 
 ## Dimension trend across sessions
-| Dim | S1 | S2 | … | Read |
-|-----|:--:|:--:|---|------|
-| A Framing | ‹b› | ‹b› | | ‹consistent? improving? context-dependent?› |
-| … | | | | |
+
+| Dim       | S1  | S2  | …   | Read                                        |
+| --------- | :-: | :-: | --- | ------------------------------------------- |
+| A Framing | ‹b› | ‹b› |     | ‹consistent? improving? context-dependent?› |
+| …         |     |     |     |                                             |
 
 ## Consistency
+
 ‹Does the candidate steer the same under pressure (debugging) as greenfield? Where does quality drop — and is the drop in a dimension that matters for the role?›
 
 ## Strongest evidence (top 3 across all sessions)
+
 1. ‹session · U‹n› · what it shows›
 
 ## Weakest evidence (top 3 across all sessions)
+
 1. ‹session · U‹n› · what it shows›
 
 ## Interview follow-ups to probe the gaps
+
 - ‹Concrete question that would confirm/deny the weakest dimension, e.g. "Walk me through how you'd have verified the worker actually drained the queue — what would you have checked?"›
 ```

package/data/harnesses/hr/skills/interview-eval/rubric.md

@@ -5,7 +5,7 @@ Score each dimension **0–5** against the anchors below. Bands are **absolute**
 Read the whole file before scoring. The general meaning of the 0–5 scale:
 
 | Band | Meaning |
-|:----:|---------|
+| :-: | --- |
 | **5** | Exemplary. The behavior a senior+ operator exhibits deliberately and consistently. |
 | **4** | Strong. Mostly present and effective, minor lapses. |
 | **3** | Competent. Present but inconsistent or shallow; gets by. |
@@ -17,13 +17,13 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 
 ---
 
-## A — Problem Framing & Specification  (weight 15)
+## A — Problem Framing & Specification (weight 15)
 
-*Did the human tell the agent what to build and why, at the right altitude, with the constraints and acceptance criteria it needed?* The opening prompt matters most, but framing recurs every time a new sub-task starts.
+_Did the human tell the agent what to build and why, at the right altitude, with the constraints and acceptance criteria it needed?_ The opening prompt matters most, but framing recurs every time a new sub-task starts.
 
-**Look for:** goal + intent ("why"), not just mechanics; explicit constraints (stack, storage, perf, scope); data shapes / interfaces / acceptance criteria; stated non-goals; the *right altitude* — outcome-with-guardrails, neither a vague one-liner nor line-by-line dictation that wastes the agent.
+**Look for:** goal + intent ("why"), not just mechanics; explicit constraints (stack, storage, perf, scope); data shapes / interfaces / acceptance criteria; stated non-goals; the _right altitude_ — outcome-with-guardrails, neither a vague one-liner nor line-by-line dictation that wastes the agent.
 
-- **5** — Specs are rich and structured: goal, constraints, data/interface shapes, and acceptance criteria are all present at the right altitude; non-goals stated; the agent has everything it needs and freedom in *how*. Re-framing on each new sub-task is equally crisp.
+- **5** — Specs are rich and structured: goal, constraints, data/interface shapes, and acceptance criteria are all present at the right altitude; non-goals stated; the agent has everything it needs and freedom in _how_. Re-framing on each new sub-task is equally crisp.
 - **4** — Clear, well-scoped specs with constraints and shapes; occasionally leaves a gap the agent has to guess, but the guess space is small.
 - **3** — Gets the core ask across but under-specifies constraints or acceptance; the agent fills meaningful gaps, sometimes wrongly, requiring a follow-up.
 - **2** — Vague or mechanics-only ("add a function that does X") with little context; the agent frequently guesses; or over-dictates exact code, wasting the agent and inviting transcription errors.
@@ -34,9 +34,9 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 
 ---
 
-## B — Decomposition & Sequencing  (weight 12)
+## B — Decomposition & Sequencing (weight 12)
 
-*Did the human break the work into coherent, dependency-ordered, individually verifiable increments?*
+_Did the human break the work into coherent, dependency-ordered, individually verifiable increments?_
 
 **Look for:** a sensible build order (foundations before features, data before UI, happy-path before edge-cases); each turn advancing a bounded step you could check; dependencies respected; no big-bang dump that forces the agent to do everything blind; no chaotic re-ordering or contradictory re-scoping.
 
@@ -51,9 +51,9 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 
 ---
 
-## C — Context Curation  (weight 10)
+## C — Context Curation (weight 10)
 
-*Did the human ground the agent in the real artifacts it needed instead of making it guess?*
+_Did the human ground the agent in the real artifacts it needed instead of making it guess?_
 
 **Look for:** pasting actual error text, logs, API responses, or stack traces; pointing at specific files (IDE-open context, `@file`, paths); referencing prior decisions to keep the agent coherent; managing the context window (not dumping irrelevant noise, not starving it); using CLAUDE.md / plan files / memory where appropriate.
 
@@ -68,13 +68,13 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 
 ---
 
-## D — Verification & Skepticism  (weight 18 — the strongest senior signal)
+## D — Verification & Skepticism (weight 18 — the strongest senior signal)
 
-*Did the human treat the agent's output as a draft to be checked — running it, reading it, probing it — rather than rubber-stamping?* This is where seniors separate from juniors. Weight it accordingly.
+_Did the human treat the agent's output as a draft to be checked — running it, reading it, probing it — rather than rubber-stamping?_ This is where seniors separate from juniors. Weight it accordingly.
 
 **Look for:** running the app/tests and reporting results; reading diffs and pushing back on questionable choices; inspecting actual behavior/output; catching subtle or superficial work the agent slipped in; confirming a fix actually fixed it before moving on; not declaring "done" on faith.
 
-> Permission mode is **not** the signal. `acceptEdits` / bypass mode is a legitimate pragmatic choice — judge whether the human *verified behavior*, by any means (running, testing, reading output, inspecting the UI), not whether they clicked approve on each edit.
+> Permission mode is **not** the signal. `acceptEdits` / bypass mode is a legitimate pragmatic choice — judge whether the human _verified behavior_, by any means (running, testing, reading output, inspecting the UI), not whether they clicked approve on each edit.
 
 - **5** — Systematic verification throughout: runs the thing, inspects real output, catches agent errors the agent missed, confirms each fix before advancing, and pushes back on shaky choices. Skepticism is the default stance.
 - **4** — Verifies most consequential output and catches real issues; a few steps taken on faith.
@@ -83,15 +83,15 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 - **1** — Effectively no verification; accepts and moves on regardless of correctness.
 - **0** — Blindly ships output known or shown to be broken.
 
-**Green flags:** "restarting the server still shows old rows" (confirming a fix *didn't* take); reading the actual response body rather than the diff; spotting that the agent stubbed/faked something. **Red flags:** "looks good" with no evidence; shipping immediately after a failed run; never once running the code in a build session.
+**Green flags:** "restarting the server still shows old rows" (confirming a fix _didn't_ take); reading the actual response body rather than the diff; spotting that the agent stubbed/faked something. **Red flags:** "looks good" with no evidence; shipping immediately after a failed run; never once running the code in a build session.
 
-**Gate interaction:** if the human is *shown* the output is broken and ships/commits it anyway, cap **D ≤ 2** and consider the BLIND-SHIP gate.
+**Gate interaction:** if the human is _shown_ the output is broken and ships/commits it anyway, cap **D ≤ 2** and consider the BLIND-SHIP gate.
 
 ---
 
-## E — Debugging Collaboration  (weight 10)
+## E — Debugging Collaboration (weight 10)
 
-*When something broke, did the human drive toward root cause with high-signal diagnostics, or just nudge vaguely?*
+_When something broke, did the human drive toward root cause with high-signal diagnostics, or just nudge vaguely?_
 
 **Look for:** precise reproduction; exact error/output pasted; expected-vs-actual framing; stated hypotheses; isolating variables one at a time; converging instead of flailing. (In a pure debugging session this is the main event; in a clean build it may be minor or `N/A`.)
 
@@ -106,9 +106,9 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 
 ---
 
-## F — Course Correction & Steering Control  (weight 10)
+## F — Course Correction & Steering Control (weight 10)
 
-*Did the human catch the agent drifting and redirect surgically — and know when to refine vs. undo vs. restart?*
+_Did the human catch the agent drifting and redirect surgically — and know when to refine vs. undo vs. restart?_
 
 **Look for:** early detection of off-track work; minimal, targeted redirects that preserve good work; tightening constraints constructively ("run 10 at a time, spend 1s per task"); well-timed interrupts; choosing the cheapest correction (refine > undo > restart). Avoid: letting a wrong path run for many turns; chaotic yanking; re-sending an identical failing prompt; nuking good work to fix a small issue.
 
@@ -123,13 +123,13 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 
 ---
 
-## G — Technical & Architectural Judgment  (weight 15)
+## G — Technical & Architectural Judgment (weight 15)
 
-*Do the prompts themselves reveal engineering maturity?* This reads the **content** of the human's instructions for evidence of senior thinking — independent of whether the agent executed well.
+_Do the prompts themselves reveal engineering maturity?_ This reads the **content** of the human's instructions for evidence of senior thinking — independent of whether the agent executed well.
 
 **Look for:** anticipating operational concerns unprompted (idempotency, reconciliation of stuck state, observability/logging, backpressure, failure/retry, race conditions, data consistency); sound trade-offs; right-sizing to context (descoping auth for a demo; not gold-plating); awareness of the system beyond the happy path; sensible tech choices for the stated constraints.
 
-> Attribute carefully: if *Claude* proposed the mature design and the human only assented, that is weaker **G** than if the human's prompt *specified* it. Note who originated the judgment.
+> Attribute carefully: if _Claude_ proposed the mature design and the human only assented, that is weaker **G** than if the human's prompt _specified_ it. Note who originated the judgment.
 
 - **5** — Prompts repeatedly surface senior-level concerns the agent wouldn't have without being told — operability, failure modes, consistency — and make sound, explicit trade-offs right-sized to the context.
 - **4** — Clear engineering maturity in most prompts; raises real operational concerns; a few missed opportunities.
@@ -142,9 +142,9 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 
 ---
 
-## H — Workflow & Tooling Leverage  (weight 5)
+## H — Workflow & Tooling Leverage (weight 5)
 
-*Did the human use the agent and harness well, and pick the right level of autonomy?* Credit when applicable; **do not penalize** a session that legitimately didn't need advanced features.
+_Did the human use the agent and harness well, and pick the right level of autonomy?_ Credit when applicable; **do not penalize** a session that legitimately didn't need advanced features.
 
 **Look for:** plan mode for genuinely ambiguous/large work; subagents for parallel or large-scope fan-out; slash commands / skills; sane git hygiene (branch, review, meaningful commits); MCP/CI where useful; matching autonomy to risk (high autonomy on safe mechanical work, tighter control on risky/irreversible work); economy of interaction.
 
@@ -155,13 +155,13 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 - **1** — Fights the tool; ignores obvious leverage; risky autonomy with no guardrails.
 - **0** — Tooling actively works against the goal.
 
-**Green flags:** plan mode before a big ambiguous build; subagents for an audit sweep; a clean commit/push flow with a written README. **Red flags:** bypass-all-permissions on destructive ops; no version control on substantial work. *(Absence of advanced features in a small, well-handled task is fine — score around 3, not down.)*
+**Green flags:** plan mode before a big ambiguous build; subagents for an audit sweep; a clean commit/push flow with a written README. **Red flags:** bypass-all-permissions on destructive ops; no version control on substantial work. _(Absence of advanced features in a small, well-handled task is fine — score around 3, not down.)_
 
 ---
 
-## I — Outcome & Efficiency  (weight 5)
+## I — Outcome & Efficiency (weight 5)
 
-*Did the session reach a correct, working end state, with economy proportional to scope?* A capstone — partly downstream of the other dimensions, so weighted light to avoid double-counting.
+_Did the session reach a correct, working end state, with economy proportional to scope?_ A capstone — partly downstream of the other dimensions, so weighted light to avoid double-counting.
 
 **Look for:** a working, correct result the human verified; effort (turns/time/tokens) proportional to the scope; little wasted looping; a clean stopping point (committed/pushed/documented).
 
@@ -181,13 +181,13 @@ When between two bands, pick the lower unless a green flag justifies the higher.
 Gates fire only on **confirmed** behavior in the transcript (use auto red-flags as leads, then verify). When a gate fires, cap the overall level as stated, record the gate, and quote the turn. Multiple gates stack downward.
 
 | Gate | Fires when | Cap |
-|------|-----------|-----|
+| --- | --- | --- |
 | **SECRETS-LEAKED** | The human pastes a live secret (API key, token, private key, real password) into a prompt, or directs the agent to commit one, and doesn't immediately remediate. | ≤ **Developing** |
 | **DESTRUCTIVE-UNCHECKED** | The human approves an irreversible/destructive op (`rm -rf` on a real path, `git push --force` to a shared branch, `DROP TABLE`/prod data loss, force-pushing over others' work) without verifying intent/scope. | ≤ **Developing** |
-| **BLIND-SHIP** | The human is *shown* output is broken (failed run, wrong result) and ships/commits/declares-done anyway, with no remediation. | **D ≤ 2** and overall ≤ **Competent** |
+| **BLIND-SHIP** | The human is _shown_ output is broken (failed run, wrong result) and ships/commits/declares-done anyway, with no remediation. | **D ≤ 2** and overall ≤ **Competent** |
 | **PROMPT-INJECTION-NAIVE** | The human pipes untrusted external content into the agent as instructions and acts on it without scrutiny in a context where that's dangerous. | ≤ **Competent** |
 
-A gate is about *unsafe steering*, not mere mistakes. A bug the candidate then caught is **not** a gate — it's evidence *for* dimension D. Distinguish "the harness/model did X" from "the human directed X": gates require human direction or human ratification.
+A gate is about _unsafe steering_, not mere mistakes. A bug the candidate then caught is **not** a gate — it's evidence _for_ dimension D. Distinguish "the harness/model did X" from "the human directed X": gates require human direction or human ratification.
 
 ---
 
@@ -207,7 +207,7 @@ A gate is about *unsafe steering*, not mere mistakes. A bug the candidate then c
 Classify the dominant type; blends are common — note them. "Primary" = weigh heavily and expect strong evidence; "Secondary" = score if present; "N/A" = exclude and renormalize unless the session actually exercises it.
 
 | Type | Primary | Secondary | Often N/A |
-|------|---------|-----------|-----------|
+| --- | --- | --- | --- |
 | **greenfield-build** | A, B, G, D | C, F, I | — |
 | **feature-add** | A, D, G | B, C, F, I | — |
 | **debugging** | E, D, C | F, G | B (little to decompose) |