# Elide Case

> Use when a court opinion that is not in the casebook has to become a casebook-style excerpt for students — "add this case to the addendum", "elide this opinion for class", "cut this case down to four pages the students can read", "make a casebook excerpt of X", "this case isn't in Choi, put it in the reader", "excerpt the Howey analysis from this opinion", "the TM mentions a case we don't have", "I want to teach this new decision next week". NEGATIVE ROUTING: compiling an addendum whose readings are already written is teaching:generate-addendum; retrieving an opinion with no elision is workflows:courtlistener.

- Skill: `edwinhu/elide-case` (Agent Skill, multi-file: 29 files)
- Install (CLI): `npx get-skill add edwinhu/elide-case`
- Raw SKILL.md: https://api.skillmd.com/api/skills/edwinhu/elide-case/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: edwinhu (https://skillmd.com/u/edwinhu)
- Updated: 2026-11-12
- Page: https://skillmd.com/skills/edwinhu/elide-case

---


# elide-case — a court opinion cut into a student reading, on the work spine

**What this skill carries** — grep `references/` for any subject the names below miss:
!`d=${CLAUDE_SKILL_DIR}; command -v skill-toc >/dev/null 2>&1 && exec skill-toc "$d"; s=$HOME/.claude/skills/plugin-utils/bin/skill-toc; [ -x "$s" ] && exec "$s" "$d"; echo "(skill-toc unavailable: references and scripts are NOT listed here — install the plugin-utils plugin, or start a new session so its bin/ reaches PATH)"`

**Typst rules in force here** — read the one that governs what you are writing; they are independent:
!`k=notes,prose; command -v typst-rules >/dev/null 2>&1 && exec typst-rules "$k"; echo "(typst corpus unavailable: NO Typst rule is listed here — install the typst plugin, or start a new session so its bin/ reaches PATH)"`

The lifecycle is [`work`](/home/eh/.claude/skills/workflows/skills/work/SKILL.md). Read it and
follow it. This file supplies `work`'s spine with the domain and nothing else — the three CLARIFY
questions, the plan grammar, the task rows, the two scored checks, the one mechanical entry point, the refs
and the authority text. **It ships no `workflow.js` and no `.js` of any kind**, and restates none of
`work`'s mechanics.

The domain rules live in `references/` and reach every dispatched agent through `refs`:

| ref | what it carries |
|---|---|
| [`references/authenticity.md`](references/authenticity.md) | the two Iron Laws — authentic reporter text, and compile-before-table |
| [`references/retrieval.md`](references/retrieval.md) | `workflows:westlaw` as the first route and the `.westlaw.docx` as the ONLY stored source, the corpus fallback (opinions vs RECAP, the 404, token gating, telling a clean source) and what that fallback's PDF cannot carry, and the two reasons to run on Gemini — a scanned source or a filter-tripping subject |
| [`references/editing-marks.md`](references/editing-marks.md) | one elision mark per addendum, `[ ]` conventions, never altering subject/tense/sentence boundary, the editors'-note rule (a note is the EXCEPTION, for background), where the mechanical conventions live (the preamble, once), the layout-only widow rule, and the source-mapping marker `// elide-source:` that check.sh reads |
| [`references/verification.md`](references/verification.md) | what each gate leg decides, and how to read a miss rate |

<EXTREMELY-IMPORTANT>
**The Iron Law of Authentic Text.** Every word of the excerpt is authentic reporter text, retrieved
this run and saved under `docs/`. Never drafted from memory, from a Teacher's Manual summary, or from
a casebook note. A plausible paraphrase handed to students as a quoted opinion is fabricated
authority in a course reader.

**The Iron Law of Compile-Before-Table.** The summary table is written AFTER the compile, from the
checker's computed output. Never before, never from an estimate.

Both are stated in full in `references/authenticity.md`, which is the `refs` entry every implementer
and the advisory fidelity reviewer must read. Refactoring this file never weakens them.
</EXTREMELY-IMPORTANT>

## Phase 1 — CLARIFY: three questions, asked with AskUserQuestion, never self-answered

**This interview is the point of the workflow.** Ask exactly these three, with `AskUserQuestion`, and
record every answer verbatim in the plan:

1. **What is the doctrinal thread, in your own words — and which assigned reading does it cut
   against?** One thread, named by the instructor, plus the case or casebook page it is in tension
   with. This is what decides every sentence that survives the cut.
2. **Is this case taught for its HOLDING or for its REASONING?** Holding means the disposition and
   the rule statement survive and the analytical march may be compressed. Reasoning means the
   analytical steps survive and the disposition may be a sentence.
3. **What is the page target for each reading?** One MIN-MAX per reading, offered with **2-6 as the
   default** option — the skill's established range — since a reading whose length he does not care
   about takes the default. A lead case and a short blog post reasonably differ, which is why the
   plan carries one target per row. When the request or the schedule already gives a target,
   **pre-fill the options from it** rather than posing the question blind; nothing is inferred
   silently, and nothing is typed at a command line.

**Do not ask anything else.** Insertion point and length are not open-ended interview axes. The per-reading page target is question 3 above, set in the interview and enforced from
the plan, because a number typed at the command line is a number an agent can invent. Insertion point
and class number still come from the request, or off the schedule if the request omits them.

### THE INTERVIEW, AND EXACTLY WHAT ENFORCES IT

Never self-answer either question, never state an assumption and continue, never infer the thread
from the Teacher's Manual or from the case itself. `work`'s CLARIFY is conversational and **a
dispatched agent cannot call `AskUserQuestion`** — a run started from a farmed-out agent has nobody
to ask, and its only correct move is to stop and report that the interview is unanswered. Elevating
the run to a session that can reach the user is the fix; guessing is not.

A doctrinal target the model states *to itself* is a silent guess; nothing makes it ask. This workflow exists to remove that path.

**The chain, with each link's real strength named.** Three things carry the interview, and only one of
them is software:

1. **The answers are recorded in the plan**, under `## Doctrinal target`, on the three labelled lines
   Phase 2 specifies.
2. **The instructor reads and approves that plan before the run arms**, and the spec hash binds what
   he approved. *This is the link that makes the answers his.* It is a human gate, and it is the only
   one there is: an instructor who approves a plan whose `## Doctrinal target` holds answers he never
   gave defeats the whole chain, and **no software in this design closes that.**
3. **`${CLAUDE_PLUGIN_ROOT}/skills/elide-case/scripts/check.sh --plan <path>` refuses a plan whose section is missing or unfilled** — absent
   section, or `Doctrinal thread:` / `Cuts against:` missing, empty or a placeholder, or `Taught for:`
   missing or saying neither holding nor reasoning. The leg fails closed: passing neither `--plan` nor
   `--no-plan` is itself a FAIL naming the missing flag, and `--no-plan` (for fixture and dev runs
   that check an addendum alone) prints a loud NOT CHECKED line.

**What that leg proves, and what it does not.** It proves the section exists and every required answer
is non-empty. It is a backstop against an **orchestrator that skipped the question** — nothing more.
The plan file is written by the orchestrator, so no grep of it can tell the user's answers from the
orchestrator's own, and `work`'s `mechanicalChecks` run at gate time, *after* IMPLEMENT, so no
mechanical leg can refuse to proceed past CLARIFY. Do not close the gap with a second
`mechanicalChecks` entry — P10 refuses one, and the leg belongs inside the single entry point.

## Phase 2 — PLAN

`work`'s Phase 2. Domain requirements on the plan:

- **A `## Readings In Scope` section**, one row per reading: `caption | source docs/*.westlaw.docx (a docs/*.txt from an
  earlier run, or from the fallback route, still resolves) | page
  target`. **This section is the source of truth for the page target**, and the `--plan` leg enforces
  it exactly as it enforces the three Doctrinal target lines: an absent section, a row with no page
  target, or a placeholder one (`TBD`, `<…>`, `N/A`) FAILS the leg naming the offending row. The
  target is per reading, from interview question 3; `check.sh` maps each `.typ` caption to its row and
  passes that row's own MIN-MAX to `check-addendum.py`. The caption is the identifier the `.typ` and the mechanical entry point key on — the entry
  point derives its per-reading checks from the captions in the `.typ`. Each row also generates one
  `cut-<slug>` task, which is how a per-reading re-run reaches `work`'s `onlyTasks`.
- **The first two CLARIFY answers, quoted** (the third is the `page target` column above), under `## Doctrinal target`, on three labelled lines the
  `--plan` leg parses — `Doctrinal thread:`, `Cuts against:`, `Taught for:` (holding or reasoning).
  A placeholder (`TBD`, `<…>`, `N/A`) reads as absent and fails the leg.
- **A `## Non-court readings` section whenever a reading is not court text** — one `- <caption> —
  <why>` bullet each, and omitted entirely when every reading is an opinion. **Declaring a reading
  non-court text is the INSTRUCTOR's call, recorded in the plan, never a marker the implementer
  writes into the `.typ`**: a self-exempting marker would let fabricated text switch the verbatim
  check off on itself, which is the first Iron Law defeated by the file it governs. The quotes leg
  reads this list from `--plan` and reports those captions `DECLARED-UNCHECKED`; a
  `// elide-unchecked:` marker in the `.typ` is no longer honoured and its presence is itself a
  FAIL naming the reading.
- **Run sizing** naming the one mechanical entry point, the two `scoredChecks` keys on the `Scored
  checks:` line marked ADVISORY, the criteria/scope checklist on the `Review lens:` line, and the
  task rows. R readings give R + 2 tasks — one `retrieve`, R `cut-<slug>`, one `compile-table` — and
  2R scored items; with one lens and one mechanical check the floor is
  2(R + 2) + 1 + 1 + 2R = 4R + 6 agents — 10 for a single reading, 22 for four readings.
- **The wave assignment, stated**: `retrieve` in wave 1, every `cut-<slug>` in wave 2, `compile-table`
  in wave 3. `work-dispatch.sh` prints the wave graph it computes; if it does not match those three
  lines, the `dependsOn` edges are wrong, not the prose.

**Writable paths for a generated run are `addenda/`, `output/addenda/` and `docs/` only.** `notes/`,
`slides/` and `templates/` are excluded, and so is everything else in the course tree.

## Phase 3 — GOAL

`work`'s Phase 3, on the PASS phrasing: a run that writes can turn a FAIL into a PASS, and `work`'s
outer fix loop is what does it.

**Condition: `work-result.sh` returned 0 for the plan path, and the tuicr gate returned approved.**

```
/goal work-result.sh has returned 0 for <plansDirectory>/<slug>.md at its current hash, and the
tuicr gate has returned approved, or stop after N turns
```

Name the plan by **path**, never by a pinned digest — the FAIL loop amends and re-hashes the plan,
so a named hash self-invalidates. Name **`work-result.sh`'s exit code**, which is the run's verdict:
`overallPass` in `result.json` is not the verdict and must never be read directly (work/SKILL.md's
`mechanicalChecks` row). Naming the returned verdict is also what makes a gate FAIL reach a stopping
condition at all — including one carried by a lens finding, which otherwise reaches none.

The condition names **no legibility or fidelity finding**. A clause like *"no critical|major finding
survives"* would reinstate the non-terminating prose review this design exists to exclude: round
*n*'s fix gives round *n+1* new things to object to. Those two run as `scoredChecks`, which cannot
reach `overallPass` at all, so their output sits in `result.json` and is **retrievable** at Phase 5 by
a human who runs the command there. Nothing carries it to him. Both named verdicts get printed, so
both are judgeable from the transcript.

## Phase 4 — the work call

The args go in the plan's `<!-- work:dispatch -->` block and the dispatch is `work`'s own
`work-dispatch.sh` — never a hand-written `farm.sh --workflow` line, which drops the TIER 1
plan-lint gate and both probe gates:

```bash
bash ~/.claude/skills/workflows/skills/work/scripts/work-dispatch.sh \
  --run-dir /home/eh/.local/state/work "$PLAN"     # ABSOLUTE — never the course tree
```

**Forward the provider.** A provider named in this skill's `$ARGUMENTS`, however it is spelled,
becomes `--provider codex` on that line. Omitting it runs the user's codex request on claude. The
content-filter facts that make this matter are in `references/retrieval.md`, alongside the other
reason a run belongs on `--provider gemini`: a source whose text came from OCR.

`--run-dir` is not optional: `work` resolves `.work/<run-id>` against `$PWD`, which on an elide run is
the course directory — a tree this run writes only `addenda/`, `output/addenda/` and `docs/` in.

The args object, complete as it stands.

**One task per reading, in three waves.** The `## Readings In Scope` table generates one `cut-<slug>`
row each — cut that reading and nothing else — above one shared `retrieve` row and below one
`compile-table` row. A second reading therefore adds exactly one task, and adds **no** lens and **no**
mechanical entry: the entry point derives its per-reading legs from the `.typ` itself. This
granularity is not cosmetic. It is what makes a per-reading re-run expressible in `work`'s own
vocabulary — see *The FAIL loop* below.

**The wave shape is forced by `work`'s disjointness rule, not chosen for tidiness.** Same-wave tasks
must have pairwise-disjoint `writablePaths`, checked prefix-aware and **refused at arg-validation,
before any agent is dispatched**. Every reading needs its source in `docs/`, so if each reading row
claimed `docs` they would all land in wave 1 claiming the same directory and a two-reading addendum
would be refused before dispatch. One row owns `docs/` instead:

| wave | rows | writable paths | why disjoint |
|---|---|---|---|
| 1 | `retrieve` (one row, however many readings) | `docs` | alone in its wave |
| 2 | one `cut-<slug>` per reading, each `dependsOn: ["retrieve"]` | `addenda/NN-addendum-<slug>.typ` | one file each, slugs distinct |
| 3 | `compile-table`, `dependsOn` every `cut-<slug>` | `output/addenda`, `addenda/NN-addendum.typ` | alone in its wave |

`retrieve` writes `docs/` and nothing else; the cut rows read it and never write it. A single-reading
run keeps all three rows — collapsing them re-introduces the overlap the moment a second reading is
added.

`retrieve` stays one serial row (P17 exempted): every Westlaw export shares the user's one signed-in browser, one delivery queue whose top item `#0_qitem` is clicked, and one Downloads directory, so concurrent retrievals can take each other's file.
<!-- wc-probe: ignore-serial-loop:start -->

```js
const addendum = /* /home/eh/areas/secreg/addenda/NN-addendum.typ with the addendum's number */
const pdf = /* /home/eh/areas/secreg/output/addenda/NN-addendum.pdf, same number */
const planPath = /* the approved plan, /home/eh/areas/secreg/.claude/plans/<slug>.md */
const goal = /* one sentence */
const args = {
  projectDir: "/home/eh/areas/secreg",          // the COURSE directory — the tree being edited
  goal,

  // ── The deterministic floor: ONE entry point, whose exit code IS the mechanical verdict. ──
  // Seven legs — the plan's interview answers (check-plan.py), typst compile, check-quotes.py per derived caption,
  // check-addendum.py --target, the strays leg (canonical widows.py/orphans.py/runts.py
  // plus check-stranded-headings.py), check-marks.py (one elision mark per addendum; every
  // retained footnote renumbered 1..k and paired), and `bin/workflow-check elide
  // --constraints-only`, which runs every constraint under checks/elide/constraints/ (where the six
  // checkers live) over the addendum and the plan — none short-circuiting. A second entry here would spread the
  // verdict over two commands and lose one silently; P10 refuses it.
  // The plan leg FAILS CLOSED: pass `--plan <md>` on a real run or `--no-plan` on a fixture run,
  // and passing neither is a FAIL naming the missing flag. `--plan` also carries the plan's
  // `## Non-court readings` declarations. It checks that the answers are RECORDED and non-empty;
  // that they are the instructor's is carried by his approval of the plan, not by this command.
  // `--plan` ALSO supplies each reading's page target, from the plan's `## Readings In Scope`
  // rows, so a real run passes NO `--target`. The plan wins if one is passed anyway — the flag is
  // ignored with a loud line naming the plan's values. `--target MIN-MAX` / `--no-target` remain
  // the fail-closed pair on `--no-plan` fixture and dev runs, where passing neither is a FAIL
  // naming the missing flag and the leg must not report length.
  // The WIDOWS leg is ON BY DEFAULT, which is its fail-closed form: an absent flag RUNS the
  // check, so no invocation can quietly certify page breaks nobody looked at. `--no-widows`
  // is the loud waiver for fixture and dev runs; passing it with `--widows` FAILS. Its fix
  // vocabulary is LAYOUT-ONLY — spacing or pagination, never the court's words, and when the
  // two conflict fidelity wins and the widow stands.
  mechanicalChecks: [
    {
      name: "elide-check",
      cmd: `bash ${CLAUDE_PLUGIN_ROOT}/skills/elide-case/scripts/check.sh --addendum ${addendum} --pdf ${pdf} --plan ${planPath}`,
    },
  ],

  // Jev scores the calibrated excerpt rules under checks/elide/rules/: an elision mark cutting
  // inside a holding or rule sentence, a heading or ordinal sequence that skips with nothing
  // marking it, editors' voice set as the court's, stress inside a quotation with no emphasis
  // notation, and a reading's note that is only mechanical boilerplate. p >= 0.85 lands in
  // rulesThatFailed and blocks; lower ones reach the lens ranked. It scores the assembled
  // addendum by --files and names no --project-dir, so it scores that one file WHOLE: the run's
  // baseline scoping (--since) is appended only to a cmd that names --project-dir. Earlier
  // readings already in the same file are therefore graded too; earlier addenda are other files.
  ruleChecks: { name: "jev-elide-rules", cmd: `bun ${CLAUDE_PLUGIN_ROOT}/skills/work/scripts/rule-check.ts --workflow elide --files ${addendum} --plan ${planPath} --project secreg` },

  tasks: [
    // ── WAVE 1: ONE row, whatever the reading count. It is the only row that writes `docs/`,
    // which is what keeps wave 2 pairwise-disjoint. See the wave table above.
    {
      id: "retrieve",
      name: "retrieve every reading's reporter text into docs/",
      work: "For EVERY row of the plan's `## Readings In Scope` table, retrieve the opinion FIRST through the `workflows:westlaw` skill, which owns the export procedure and the .westlaw.docx naming convention and yields publisher-keyed text needing no OCR adjudication. THE DOCX IS THE ONLY ARTIFACT: it is the golden copy, its text projection is in memory, and you write no .txt beside it — a stored twin drops the docx's italic runs, so a case name the court italicised would compile in roman. Fall back to ${CLAUDE_PLUGIN_ROOT}/skills/elide-case/scripts/fetch-opinion.sh — saving both docs/<name>.pdf and docs/<name>.txt under the naming convention already in docs/ — only when Westlaw does not cover the case or no Westlaw credential is available; that route yields a court PDF with NO formatting layer, so its italics are unrecoverable and the gate says so on every reading cut from one. On that fallback, a citation 404 means 'not in the opinions corpus', not 'no such case' — take the RECAP docket-entry route. Retrieve and nothing else: write no addenda file, cut no text, and do not edit an excerpt. A reading whose source cannot be retrieved is reported as such — never substituted with a related opinion, a Teacher's Manual summary or a previous excerpt.",
      writablePaths: ["docs"],
      acceptance: "Every `## Readings In Scope` row has its retrieved source on disk under /home/eh/areas/secreg/docs/ — <name>.westlaw.docx ALONE on the Westlaw route, or <name>.pdf plus <name>.txt on the corpus fallback — and each is the reporter text of that row's caption — `check-source-identity.py` (a leg of check.sh's constraints leg) fails a `.docx` source that does not contain the caption's reporter citation; a Route 2 `.txt` lacking it is reported IDENTITY NOT CHECKED (exit 0), because a slip opinion or RECAP entry carries no reporter citation, so the Phase 5 reader confirms that source by eye. Writing a <name>.westlaw.txt for a source retrieved THIS RUN fails this row — the projection is in memory. A .westlaw.txt already in docs/ from an earlier run is left alone: an addendum whose plan or `// elide-source:` names one still resolves and still passes, and deleting it would break a gate that was green.",
      redDisposition: "Retrieval writes no excerpt, so there is no behaviour a redCommand could hold red: the run's mechanical entry point cannot run at all until wave 2 has produced a .typ to check. The per-task Verify channel adjudicates the files this row is responsible for.",
      refs: [
        "${CLAUDE_PLUGIN_ROOT}/skills/elide-case/references/authenticity.md",
        "${CLAUDE_PLUGIN_ROOT}/skills/elide-case/references/retrieval.md",
      ],
    },
    // ── WAVE 2: ONE ROW PER READING. Copy this row for each `## Readings In Scope` line,
    // substituting the slug, caption, source basename and page target. Each row cuts its own
    // reading, so `tasksThatFlagged` on a FAIL names exactly the readings to re-cut. Each writes
    // ONE fragment and never `docs/` — that is what makes the wave disjoint.
    {
      id: "cut-<slug>",
      name: "cut <caption>",
      work: "ONE READING, CUT ONLY. Write the excerpt into addenda/NN-addendum-<slug>.typ, from the docs/<source> the `retrieve` task saved (the file the plan's source column names: the .westlaw.docx, or the .txt on the Route-2 fallback) and from nothing else; check-quotes.py projects a docx to text in memory, so read a docx the same way rather than writing one out. THE EXCERPT INHERITS THE COURT'S ITALICS FROM THE SOURCE and must neither invent nor drop them: a case name the projection carries as `_Weinberger_` is set as `_Weinberger_` in the .typ, and emphasis the source does not carry is not added. You do not write docs/; if the source is missing or unreadable, stop and report it rather than retrieving it yourself. Keep only the transaction structure, the analysis of the ONE thread the plan's Doctrinal target section quotes, and the reasoning that puts the case in tension with the assigned reading it names. Holding-taught means the disposition and rule statement survive; reasoning-taught means the analytical steps do. Caption block and judge line follow addenda/01-addendum.typ. EDITORS' NOTE — the default is NO note (instructor ruling). Write one only when this reading needs BACKGROUND the student cannot read the case without: prior history of the same litigation, an earlier related decision, or real-world context. The mechanical conventions — the elision mark, footnotes omitted except as indicated and renumbered, record citations dropped without notation — are stated ONCE in the addendum's preamble and cover every reading; do not repeat them per reading. Elision marks and the disclosure rule are in editing-marks.md — an elided passage may instead be replaced by `#emph[[Summary: ...]]` (<= 40 words, between sentences, no quotation, figure or holding), whose form is in editing-marks.md and which check-marks enforces; record citations, party-brief citations, string cites and internal cross-references may go silently; a dropped substantive footnote, qualifier, alternative holding or dissent may not, and a disclosure specific to THIS reading (e.g. it retains footnote 16 renumbered as 1) goes in this reading's own note. SOURCE MAPPING: check.sh derives each reading's source from its caption and resolves it to the .docx. When that derivation is wrong or ambiguous, declare the file with `// elide-source: <basename.westlaw.docx>`, whose syntax and placement are in editing-marks.md — never point it at a loosely related file to quiet a NOSOURCE, and note that it names a file that must exist, so it cannot exempt anything. You may NOT declare a reading non-court text: `// elide-unchecked:` is no longer honoured and writing one is itself a FAIL, because the agent writing the excerpt cannot be the one who switches the verbatim check off on it. A reading with no reporter source stops and reports to the instructor, who declares it in the plan's `## Non-court readings` section.",
      writablePaths: ["addenda/NN-addendum-<slug>.typ"],
      dependsOn: ["retrieve"],
      // Task-specific: check-quotes.py for THIS caption alone. Not the run's entry point — a task
      // graded by the shared command can be reported done because a DIFFERENT task's work made it
      // pass, which leaves `work`'s per-task Verify channel nothing task-specific to judge.
      acceptance: "python3 ${CLAUDE_PLUGIN_ROOT}/checks/elide/constraints/check-quotes.py /home/eh/areas/secreg/addenda/NN-addendum-<slug>.typ /home/eh/areas/secreg/docs/<source> --caption '<this reading's caption>' --skip-editorial exits 0, having checked a non-zero number of sentences for that caption. <source> is the file the plan's source column names for this reading: the .westlaw.docx, or the .txt on the Route-2 fallback.",
      redDisposition: "The behaviour this task must satisfy is already executed by the run's one mechanical entry point, whose check-quotes.py leg is red before the excerpt exists and green after; a redCommand here would be that same command run a second time by a second agent.",
      refs: [
        "${CLAUDE_PLUGIN_ROOT}/skills/elide-case/references/authenticity.md",
        "${CLAUDE_PLUGIN_ROOT}/skills/elide-case/references/editing-marks.md",
      ],
    },
    // ── WAVE 3: alone, so its two writable paths collide with nothing.
    {
      id: "compile-table",
      name: "compile, then write the table from the computed rows",
      work: "Assemble the per-reading fragments into addenda/NN-addendum.typ in the plan's Readings In Scope order, compile via teaching:generate-addendum, then run check-addendum.py --target and paste ITS computed rows into the summary table. THE PREAMBLE CARRIES THE MECHANICAL CONVENTIONS FOR THE WHOLE DOCUMENT — one sentence covering the elision mark, footnotes omitted except as indicated and renumbered, and record citations dropped without notation. This row owns that sentence, because it owns the preamble; a per-reading note repeating it is the boilerplate the no-default-note rule removes. Never hand-edit a range to make the checker pass — the checker is reporting the truth about the PDF. On a length or arity miss, fix the offending READING's fragment and recompile; do not rewrite a fragment this row did not break.",
      writablePaths: ["output/addenda", "addenda/NN-addendum.typ"],
      // Task-specific: check-addendum.py's own arity, table-truth and length legs against the
      // compiled PDF. The run's entry point stays the WHOLE mechanical verdict without also being
      // this task's only grader.
      acceptance: "python3 ${CLAUDE_PLUGIN_ROOT}/checks/elide/constraints/check-addendum.py /home/eh/areas/secreg/addenda/NN-addendum.typ /home/eh/areas/secreg/output/addenda/NN-addendum.pdf --target <the page target the plan's `## Readings In Scope` rows carry; when the rows differ, run the run's entry point instead, which reads each row's own target> exits 0 — summary-table rows equal readings found (arity), every stated page range matches the compiled PDF (table truth), and each reading is inside its target (length).",
      dependsOn: ["cut-<slug>" /* , one id per reading row; `retrieve` is reached transitively */],
      redDisposition: "Work whose whole acceptance is the run's mechanical entry point; `work` re-runs that command in a shell to adjudicate it, so a redCommand would duplicate the gate rather than gate the task.",
      refs: [
        "${CLAUDE_PLUGIN_ROOT}/skills/elide-case/references/authenticity.md",
        "${CLAUDE_PLUGIN_ROOT}/skills/elide-case/references/verification.md",
      ],
    },
  ],

  // ── legibility and fidelity are `scoredChecks`, and that is WHY they are advisory. ──
  // The `lens` gates by construction: the work skill's workflow.js computes overallPass FROM the
  // blocking lens findings that stand, so folding these two into the lens prompt and calling them
  // advisory in prose would be a claim about the spine rather than a parameter to it. `scoredChecks` is the mechanism
  // that carries the property: overallPass is computed without reading any scored value, there is no
  // threshold and no blockBelow, it opens no selector channel, and a dead agent does not flip the
  // verdict (work/references/scored-checks.md, S6/S7). That is ~/.claude/CLAUDE.md rule 9 satisfied
  // structurally — an open-ended prose review cannot gate a loop, because round n's fix gives round
  // n+1 new things to object to.
  //
  // ONE ITEM PER READING, so a score reads per reading exactly as a task does. Each agent returns
  // RAW COUNTS and never sees the weights below, which is what stops a self-graded score.
  scoredChecks: [
    {
      key: "legibility",
      items: ["<caption>" /* , one per `## Readings In Scope` row */],
      agentType: "Explore",
      refs: ["${CLAUDE_PLUGIN_ROOT}/skills/elide-case/references/editing-marks.md"],
      prompt: "Read this reading's excerpt in addenda/NN-addendum.typ as a student would, with no access to the full opinion. Count ONLY these five defect kinds, and report COUNTS plus the offending sentences verbatim: (1) unparsable — a sentence that does not parse as a sentence; (2) fusedElision — an elision that joins two fragments into something the court did not write; (3) danglingReferent — a pronoun or 'it'/'that' whose referent was cut; (4) unattributedQuote — a block quote whose speaker is not identifiable from the excerpt alone; (5) undefinedTermOfArt — a term of art used before it is introduced. Anything outside those five is not counted here. `itemsChecked` is the number of sentences you actually read; report 0 only if you read none, which marks the item unreliable rather than clean.",
      schema: {
        type: "object",
        additionalProperties: false,
        required: ["itemsChecked", "unparsable", "fusedElision", "danglingReferent", "unattributedQuote", "undefinedTermOfArt"],
        properties: {
          itemsChecked: {type: "integer"},
          unparsable: {type: "integer"},
          fusedElision: {type: "integer"},
          danglingReferent: {type: "integer"},
          unattributedQuote: {type: "integer"},
          undefinedTermOfArt: {type: "integer"},
          offendingSentences: {type: "array", items: {type: "string"}},
        },
      },
      passthrough: ["offendingSentences"],
      components: [
        {name: "reads", weight: 1.0, base: 10, penalties: {unparsable: 2.0, fusedElision: 2.0, danglingReferent: 1.0, unattributedQuote: 1.0, undefinedTermOfArt: 0.5}},
      ],
    },
    {
      key: "fidelity",
      items: ["<caption>" /* , one per `## Readings In Scope` row */],
      agentType: "Explore",
      refs: ["${CLAUDE_PLUGIN_ROOT}/skills/elide-case/references/authenticity.md"],
      prompt: "Verbatim matching cannot see misrepresentation. Judge whether the CUT misrepresents the opinion, reading this reading's excerpt against its full source docs/<source>, the file the plan's source column names. A .westlaw.docx cannot be opened by Read: project it to text with `python3 ${CLAUDE_PLUGIN_ROOT}/skills/westlaw/scripts/westlaw-docx-text.py docs/<source>` (Bash) and read that output; never write it to disk. A .txt (Route-2 fallback) is read directly. Count ONLY these five, and report COUNTS plus the excerpt passage and the source line for each: (1) quotedAsOwnReasoning — a passage the court QUOTES FROM ANOTHER CASE presented as the court's own reasoning  (e.g. a block quote the court cites only to reject, rendered as running text); (2) unqualifiedHolding — a holding stated without the qualifier that limits it; (3) omittedAlternativeHolding — an omitted alternative holding that changes what the case stands for; (4) dissentAsMajority — a dissent's language read as the majority's; (5) misstatedSummary — an editorial `#emph[[Summary: ...]]` that misstates, slants or adds to the passage it stands in for (trace it to the source text cut at that point). `itemsChecked` is the number of excerpt passages you traced back to the source; 0 marks the item unreliable rather than clean.",
      schema: {
        type: "object",
        additionalProperties: false,
        required: ["itemsChecked", "quotedAsOwnReasoning", "unqualifiedHolding", "omittedAlternativeHolding", "dissentAsMajority", "misstatedSummary"],
        properties: {
          itemsChecked: {type: "integer"},
          quotedAsOwnReasoning: {type: "integer"},
          unqualifiedHolding: {type: "integer"},
          omittedAlternativeHolding: {type: "integer"},
          dissentAsMajority: {type: "integer"},
          misstatedSummary: {type: "integer"},
          offendingPassages: {type: "array", items: {type: "string"}},
        },
      },
      passthrough: ["offendingPassages"],
      components: [
        {name: "faithful", weight: 1.0, base: 10, penalties: {quotedAsOwnReasoning: 3.0, unqualifiedHolding: 2.0, omittedAlternativeHolding: 2.0, dissentAsMajority: 3.0, misstatedSummary: 2.0}},
      ],
    },
  ],

  // One lens after verification and mechanical checks; legibility and fidelity remain advisory above.
  lens: {
    agentType: "Explore",
    refs: ["${CLAUDE_PLUGIN_ROOT}/skills/elide-case/references/editing-marks.md"],
    prompt: "Judge the delivered artifacts against the approved plan and the goal. CHECKLIST: (1) CRITERIA vs ARTIFACTS — for each success criterion in the plan and goal, is there an artifact that satisfies it? Missing or partial satisfaction is a finding, CRITICAL where the deliverable cannot stand without it. (2) SCOPE FIDELITY — did the changes stay inside the plan's task table and writable paths, limited to addenda/, output/addenda/ and docs/? Out-of-scope edits, unrequested features and silently skipped readings are findings, CRITICAL where an edit landed outside every declared writable path. Severity is MAJOR at minimum. Legibility and fidelity are advisory scoredChecks, not additional checklist items here. Holding-cutting elisions, unmarked heading or ordinal skips, editors' voice in the court's text, un-noted emphasis in quotations and boilerplate notes are the jev-elide-rules verdicts in the digest: do not re-grade them, except to rule on a verdict the digest ranks below the block line. MODE — RED (a task was flagged or a mechanical check failed): diagnose EVERY failure in the digest and route it with cause and fix to its owner task id, or to 'plan' when no task can own the fix. MODE — GREEN (everything passed): make one open-ended pass over the checklist and report each finding with an ownerTask. In both modes, rule every carried finding open or closed against evidence you actually read; silence leaves it open.",
  },

  authorityExtra: "DOMAIN RULE — every word of the excerpt is authentic reporter text, cut from the .westlaw.docx retrieved THIS RUN into docs/ and projected to text in memory — never from a .txt written beside it, which is not produced. Never from memory, a Teacher's Manual summary, a casebook note, or a previous excerpt. DOMAIN RULE — the summary table is written after the compile, from the checker's computed rows; never hand-edit a range to make the checker pass. WRITE SURFACE — addenda/, output/addenda/ and docs/ only. notes/, slides/ and templates/ are excluded, and notes/07-security.typ may be open in the user's editor. THE TYPST CORPUS IS ONE COMMAND AWAY, AND IS NOT IN YOUR REFS. Run `typst-rules notes,prose` for the index, then read the ones your edit touches; it is on PATH and needs no path or plugin variable. Do not work from a paraphrase of these rules.",

  maxAgents: 50,
}
```
<!-- wc-probe: ignore-serial-loop:end -->

## Phase 5 — HUMAN REVIEW

`work`'s Phase 5, on the compiled PDF: the reviewer reads the reading, not the diff. Open the PDF
beside `human-review-gate.sh -w`.

### Where the legibility and fidelity scores actually are

**They are in `result.json` under `scores[]`, and nothing delivers them.** `work` returns each item's
computed score, its raw counts, and — because `passthrough` declared them — the verbatim offending
text under `evidence`. Phase 5 is a human step, so no exit code can compel anyone to look. Print them
with one command:

```bash
jq -r '.scores[] | "\(.key)  \(.item)  composite=\(.composite // "null")  itemsChecked=\(.itemsChecked // "n/a")  \(.reason // "")",
       "  components: \(.components // {} | tojson)",
       "  evidence:   \(.evidence   // {} | tojson)"' \
  /home/eh/.local/state/work/<run-id>/result.json
```

The field is `composite`, not `score` — `work` emits one `scores[]` entry per (key, item) pair as
`{key, item, components, composite, itemsChecked, evidence, reason?}`, and there is no cross-item
mean or total to read.

**This is an INSTRUCTION, not a gate, and the distinction is the whole design.** The scores cannot
fail the run by construction — that is exactly why they are `scoredChecks` and not the `lens` —
and therefore a reviewer who does not run that command does not see them. That is the accepted cost
of their not gating, and it is stated here rather than papered over with a sentence claiming they are
"reported".

**If that cost is unacceptable on a given run, the remedy is NOT to fold them into the `lens` prompt**
— that reinstates the non-terminating prose gate rule 9 forbids — it is for the instructor to read
the excerpt himself, which is what Phase 5 is for.

When the reviewer does want them in the findings file, write `result.json`'s `scores[]` there before
opening the PDF, one section per reading, naming the fields:

```
## Advisory scores — legibility and fidelity (these gate nothing)

### <caption>
legibility  composite <n>/10   itemsChecked <n>
  unparsable <n> · fusedElision <n> · danglingReferent <n> · unattributedQuote <n> · undefinedTermOfArt <n>
  evidence.offendingSentences:
    - "<verbatim sentence>"
fidelity    composite <n>/10   itemsChecked <n>
  quotedAsOwnReasoning <n> · unqualifiedHolding <n> · omittedAlternativeHolding <n> · dissentAsMajority <n> · misstatedSummary <n>
  evidence.offendingPassages:
    - "<verbatim excerpt passage, and the source line it was traced to>"
```

Three rules on the rendering, because each is a way the output silently stops meaning anything:

- **`evidence.offendingSentences` and `evidence.offendingPassages` are the whole point of the
  passthrough declarations** — the counts say how many, the evidence says which. Render the verbatim
  text. A section showing counts with no evidence gives the reviewer nothing to act on.
- **A `null` `composite` is rendered as `null` WITH its stated `reason`** — never as `0`, never as a blank,
  never omitted. `null` means the item was unreliable or its agent died; `0` means it was measured
  and scored zero. Collapsing them turns "nothing checked this reading" into "this reading is bad",
  and the reviewer cannot tell.
- **`scores: []` with `scoresRun`/`scoresReported` as `null` is n/a, not clean.** Say the phase did
  not run rather than printing an empty section that reads as nothing found.

The reviewer decides what to do with all of it. A low score re-runs nothing by itself — see *The FAIL
loop*.

## The FAIL loop — `work`'s selectors, and where the per-reading granularity comes from

The selector is `work`'s own, all four channels, consumed together: `tasksThatFlagged`,
`mechanicalThatFailed`, `lensesThatFlagged` and `planFindings`. A scoped re-run is `onlyTasks` +
`priorResults`, derived by `work-redispatch.sh` from the result. **There is no caption channel** — `work` scopes by
task id and nothing else, so a re-run instruction phrased as "re-cut the failing caption" names a
dimension `work` does not have and cannot be executed.

**Per-reading re-cutting falls

…(truncated)
