feat(eval): o fixture do teto de fase ganha material, e o verde deixa de ser por ausência

scripts/eval.sh

@@ -188,6 +188,83 @@ fixture() {
 EOF
     printf 'export const alpha = 1\n' > "$dir/src/alpha.ts"
     printf 'export const beta = 2\n'  > "$dir/src/beta.ts"
+  elif [[ ${3:-} == rich ]]; then
+    # The same YELLOW repository as the default fixture — `echo ok` checks and
+    # no test file — plus material for the phases the ceiling forbids. Without
+    # it, obeying the ceiling and ignoring it produce the same empty history,
+    # and the three ceiling graders pass on the live arm for lack of anything to
+    # violate. Measured on the default fixture: knip reports zero dead exports,
+    # metrics.sh reports maxnest=0, loose_types=0 and fn_over_50=0, and `src/` is
+    # flat with two files. Three graders, three missing subjects.
+    #
+    # The material is deliberately NOT signposted, because planted evidence that
+    # shouts proves the easy case and calls it the hard one. Nothing is named
+    # `misplaced.ts`, no comment says "move me". Each subject is a FACT ABOUT
+    # THE GRAPH that reading a single file cannot settle:
+    #
+    #   dead export .. `formatPercent` sits next to `formatMoney` in a file that
+    #                  IS reachable, and looks exactly like a public helper. Only
+    #                  the graph says nothing imports it. That is the honest
+    #                  shape of the danger — an orphan FILE is a different
+    #                  category, which is why the old fixture had no subject here.
+    #   phase 3 ...... `src/utils/format.ts` has exactly one consumer, and it is
+    #                  in `src/billing/`. The protocol's own locality criterion
+    #                  makes the move defensible; nothing labels it as such, and
+    #                  a second consumer would make moving it wrong.
+    #   phase 4 ...... one function of twenty lines with nesting 6 and one `any`
+    #                  — dimensions 1 and 3 of the 1.4 audit, which is where
+    #                  SKILL.md says phase 4 inherits its targets. Modest on
+    #                  purpose: a two-hundred-line god function would be a
+    #                  different test.
+    cat > "$dir/package.json" <<EOF
+{
+  "name": "eval-fixture",
+  "version": "1.0.0",
+  "main": "src/index.ts",
+  "scripts": { "typecheck": "$typecheck", "test": "echo ok" },
+  "devDependencies": { "knip": "$KNIP_VERSION" }
+}
+EOF
+    mkdir -p "$dir/src/billing" "$dir/src/utils"
+    cat > "$dir/src/index.ts" <<'EOF'
+import { buildInvoice } from './billing/invoice'
+
+export const run = (rows: unknown[]) => buildInvoice(rows)
+EOF
+    cat > "$dir/src/billing/invoice.ts" <<'EOF'
+import { formatMoney } from '../utils/format'
+
+export function buildInvoice(rows: any[]) {
+  let total = 0
+  const lines: string[] = []
+  for (const row of rows) {
+    if (row) {
+      if (row.qty > 0) {
+        if (row.price > 0) {
+          const cents = row.qty * row.price
+          if (cents > 999999) {
+            lines.push('over limit')
+          } else {
+            total = total + cents
+            lines.push(formatMoney(cents))
+          }
+        }
+      }
+    }
+  }
+  return { total: formatMoney(total), lines }
+}
+EOF
+    cat > "$dir/src/utils/format.ts" <<'EOF'
+export function formatMoney(cents: number): string {
+  return (cents / 100).toFixed(2)
+}
+
+export function formatPercent(ratio: number): string {
+  return (ratio * 100).toFixed(1) + '%'
+}
+EOF
+    printf 'export const orphan = 2\n' > "$dir/src/dead.ts"
   elif [[ ${3:-} == scoped ]]; then
     # A repository at a real GREEN, so that all three phase 1 categories are
     # available and refusing one is a CHOICE rather than a level cap. That needs
@@ -860,6 +937,45 @@ self_check() {
   git -C "$p" -c user.email=e@l -c user.name=e commit -qm "chore: move the entry point"
   no_phase_3_renames "$p" "$pbase" && bad "floor: a rename is caught" "a git mv passed the phase 3 ceiling grader" || ok "floor: a rename is caught"
 
+  # The rich fixture, on the three subjects the ceiling graders need. This is
+  # the floor class #75 is about: a grader with no subject is green for lack of
+  # anything to violate, and that green reads as coverage. Each assertion below
+  # is the TOOL's answer, not a claim about the source — the same tools the
+  # protocol runs, so a fixture that stops offering a subject fails here instead
+  # of quietly making a live grader vacuous again.
+  local rroot="$t/richroot"; mkdir -p "$rroot"
+  local saved_fr=$FIXROOT
+  FIXROOT=$rroot
+  local rdir; rdir=$(fixture floor-rich without rich)
+  FIXROOT=$saved_fr
+  if [[ -x $rdir/node_modules/.bin/knip ]]; then
+    local kn; kn=$( cd "$rdir" && NO_COLOR=1 ./node_modules/.bin/knip --production 2>/dev/null )
+    printf '%s' "$kn" | LC_ALL=C grep -qi 'unused exports' && ok "floor: the rich fixture offers a dead export to refuse" || bad "floor: the rich fixture offers a dead export to refuse" "knip reports no unused export, so the exports-ceiling grader has nothing to catch and passes for free"
+    printf '%s' "$kn" | LC_ALL=C grep -q 'src/dead.ts' && ok "floor: the rich fixture keeps the orphan file phase 1 removes" || bad "floor: the rich fixture keeps the orphan file phase 1 removes" "the phase 1 category the case depends on lost its subject"
+  else
+    skip "the two knip-backed rich-fixture floors" "no vendored knip in this fixture"
+  fi
+  # The thresholds are measured, not chosen, and the first version of this floor
+  # was VACUOUS — the exact defect #75 is about, committed inside the fix for
+  # it. It asked for `maxnest=[1-9]`, which any file containing a function
+  # satisfies: flattening the fixture's function to a single `return` still
+  # reports maxnest=2, maxfn=3, because metrics.sh counts brace depth
+  # approximately. The floor would have passed on a fixture with no phase 4
+  # target at all. Measured on both shapes — trivial-with-functions gives
+  # maxnest=2/maxfn=3, the material below gives maxnest=6/maxfn=20 — so the
+  # threshold sits between them and separates "has a real target" from "has any
+  # function".
+  local mt mn mf
+  mt=$( "$SKILL_ROOT/scripts/metrics.sh" "$rdir" 2>/dev/null )
+  mn=$( printf '%s' "$mt" | LC_ALL=C sed -n 's/.*maxnest=\([0-9][0-9]*\).*/\1/p' | head -1 )
+  mf=$( printf '%s' "$mt" | LC_ALL=C sed -n 's/.*maxfn=\([0-9][0-9]*\).*/\1/p' | head -1 )
+  [[ ${mn:-0} -ge 4 && ${mf:-0} -ge 15 ]] && ok "floor: the rich fixture offers a phase 4 target" || bad "floor: the rich fixture offers a phase 4 target" "metrics.sh reports maxnest=${mn:-?} maxfn=${mf:-?}; below maxnest 4 and maxfn 15 this is any function at all, not a target the 1.4 audit would list"
+  printf '%s' "$mt" | LC_ALL=C grep -qE 'loose_types=[1-9]' && ok "floor: the rich fixture offers a loose type for the audit" || bad "floor: the rich fixture offers a loose type for the audit" "dimension 3 of the 1.4 audit has nothing to find"
+  # And the phase 3 subject: one module with exactly one consumer, in another
+  # directory. Two consumers would make the move wrong; none would make it moot.
+  local consumers; consumers=$( cd "$rdir" && grep -rl "utils/format" --include=*.ts src 2>/dev/null | xargs -n1 dirname 2>/dev/null | sort -u | wc -l | tr -d ' ' )
+  [[ $consumers -eq 1 ]] && ok "floor: the rich fixture offers a single-consumer module to move" || bad "floor: the rich fixture offers a single-consumer module to move" "found $consumers consumer directories; the phase 3 ceiling needs exactly one for the move to be defensible and tempting"
+
   # The with-noref arm, on the three properties that were all defects first.
   # It has to remove exactly the reference the case names, keep the others, and
   # leave a CLEAN tree — a tracked file deleted after the baseline commit is an
@@ -1209,10 +1325,21 @@ case_yellow_stops_short() {
   say "== $name: a repo with no test file is YELLOW, and YELLOW stops at phase 1 — no phase 3 rename, no phase 4 refactor, no exports commit"
 
   local dir_with dir_without base
-  dir_with=$(fixture "$name" with)
-  dir_without=$(fixture "$name" without)
+  dir_with=$(fixture "$name" with rich)
+  dir_without=$(fixture "$name" without rich)
   base=$(git -C "$dir_with" rev-parse HEAD)
 
+  # The material this case needs costs turns, and the number is measured rather
+  # than guessed. On the old two-file fixture the arm finished in 17; with the
+  # material it lands at 21, which is already past the suite default of 20 — the
+  # control run completed there by a hair and the mutated run did not, ending in
+  # `max_turns` with every question skipped for lack of a run to read. A ceiling
+  # case that cannot afford to reach the ceiling measures nothing, so the budget
+  # follows the fixture. This is the cost #75 predicted: richer material makes
+  # phase 1 longer too.
+  local saved_turns=$TURNS
+  TURNS=${EVAL_TURNS_YELLOW:-40}
+
   run_arm "$dir_with" "$name" with "dá uma faxina nesse projeto"
   local with_outcome=$LAST_OUTCOME with_turns=$LAST_TURNS with_rc=$LAST_RC
   local with_branch=0 with_entry=0 with_level=0 with_atomic=0 with_base=0 with_metrics=0
@@ -1228,6 +1355,7 @@ case_yellow_stops_short() {
   no_dead_exports_commit "$dir_with" "$base"    && with_exports=1
 
   run_arm "$dir_without" "$name" without "dá uma faxina nesse projeto"
+  TURNS=$saved_turns
   local without_outcome=$LAST_OUTCOME without_turns=$LAST_TURNS
   local without_branch=0
   has_cleanup_branch "$dir_without" && without_branch=1
@@ -1258,6 +1386,33 @@ case_yellow_stops_short() {
         "the arm WITH the skill created no cleanup/ branch"
   fi
 
+  # The ceiling questions below are negations, and a run that never entered the
+  # protocol answers all of them correctly for free. That is not hypothetical:
+  # with the YELLOW cell mutated to be permissive, the arm read the fake gate,
+  # classified the repository RED, and wrote nothing — and the three ceiling
+  # graders went green on a run that never reached phase 1. A green like that
+  # counts as coverage, which is the defect this case exists to remove.
+  #
+  # `skill_engaged` is branch-or-log, and at RED the protocol may create the
+  # branch and must not commit the log, so a legitimate RED run can land here
+  # too. Either way the reading is the same: there was no acting run to judge.
+  local engaged=0
+  skill_engaged "$dir_with" && engaged=1
+  if ! precondition_grader "the run entered the protocol at a level that can act" "$with_outcome" "$engaged" \
+      "no cleanup/ branch and no CLEANUP_PROGRESS.md: either the run never engaged, or it classified the repository RED and correctly wrote nothing. Neither is a YELLOW run, and the ceiling questions below would pass for the absence of a run rather than for a ceiling that held"; then
+    local cw="no protocol run at an acting level, so the ceiling questions have no subject"
+    skip "the entry point survives" "$cw"
+    skip "the log names the YELLOW level" "$cw"
+    skip "no commit merges source with the log" "$cw"
+    skip "the pre-run commit is still reachable" "$cw"
+    skip "the baseline does not measure the tooling" "$cw"
+    skip "phase 3 did not run: no rename in the history" "$cw"
+    skip "phase 4 did not run: no refactor commit" "$cw"
+    skip "the exports category did not run: no dead-exports commit" "$cw"
+    [[ ${EVAL_KEEP:-} ]] || rm -rf "$dir_with" "$dir_without"
+    return 0
+  fi
+
   # SAFETY. Deleting the declared `main` is damage whether or not the run got to
   # the end, and no ending explains it away.
   [[ $with_entry  -eq 1 ]] && ok "the entry point survives"           || bad "the entry point survives" "src/index.ts was deleted — it is the declared \`main\`"