ll-skills 2.0.2 → 3.1.0

package/scripts/evals/cases/auto-empty-repo/assert.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# "/ll-auto" on an empty repository -> the two-line stop, no question, nothing written.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")/../../lib" && pwd)/assert.sh"
+
+WORK="$1"; OUT_JSON="$2"; OUT_TXT="$3"
+
+contains "$OUT_TXT" 'Nada encontrado neste reposit' 'the answer carries the empty-repository line'
+contains "$OUT_TXT" '/ll-auto "<objetivo>"' 'the answer carries the command to complete'
+
+no_path "$WORK/docs" 'no docs/ was created'
+no_path "$WORK/PLAN.md" 'no PLAN.md was created'
+
+# OUT_JSON may sit inside WORK for an offline check; exclude it by name so the
+# capture file itself is not read as a change to the work tree.
+dirty="$(git -C "$WORK" status --porcelain 2>/dev/null | grep -v -- " $(basename "$OUT_JSON")\$")"
+if [ -z "$dirty" ]; then
+  ok 'git status --porcelain is empty: nothing was written'
+else
+  fail "the working tree was changed: $(printf '%s' "$dirty" | tr '\n' ' ')"
+fi
+
+no_tool_use "$OUT_JSON" AskUserQuestion 'no AskUserQuestion tool call anywhere in the capture'
+no_tool_use "$OUT_JSON" Skill 'no Skill tool call anywhere in the capture'
+
+finish

package/scripts/evals/cases/auto-empty-repo/case.json

@@ -0,0 +1,8 @@
+{
+  "max_turns": 10,
+  "history": false,
+  "min_pass": 1,
+  "agent": null,
+  "permission_mode": "bypassPermissions",
+  "note": "Own fixture holding only .gitkeep (an empty repository). Proves the empty-repo stop: two exact lines, no question, nothing written. max_turns 10 (B-018): the `num_turns` the result reports counts the skill's `!` preprocessor Bash calls and the model's own tool calls together — real reps of this case reported 3 and 7 while the cap was 4 and the run still ended `success`, so the two numbers are not the same unit. The cap is pinned above the highest count seen, so a rep that really runs long is cut instead of scoring."
+}

package/scripts/evals/cases/auto-empty-repo/prompt.txt

@@ -0,0 +1 @@
+/ll-auto

package/scripts/evals/cases/decide-final-round/assert.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# The final round is always sent, with the counter, before anything is frozen.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")/../../lib" && pwd)/assert.sh"
+
+WORK="$1"; OUT_JSON="$2"; OUT_TXT="$3"
+
+# a one-shot run has no owner to answer: either the final round (counter) or a blocking gate block (≤ 4 questions) is the correct stop
+if grep -qE 'questions asked' "$OUT_TXT"; then
+  contains "$OUT_TXT" 'owner decisions open' 'the final round carries "owner decisions open"'
+else
+  contains "$OUT_TXT" '\[PG-1\]|Pergunta 1/|Question 1/' 'the gate asks its first question instead of assuming'
+  n="$(grep -cE '^\*\*\[PG-[0-9]+\]|^\*\*Pergunta [0-9]+/|^\*\*Question [0-9]+/' "$OUT_TXT")"
+  if [ "$n" -le 4 ]; then ok "the block carries $n questions (≤ 4)"; else fail "the block carries $n questions (> 4)"; fi
+  no_path "$WORK/PLAN.md" 'nothing frozen while the gate is open'
+fi
+
+# The decision room is handed over before the first question, never after it (F-5).
+if grep -qE 'OPTIONS\.html' "$OUT_TXT"; then
+  opt="$(grep -nE 'OPTIONS\.html' "$OUT_TXT" | head -1 | cut -d: -f1)"
+  q="$(grep -nE 'Pergunta 1/|Question 1/' "$OUT_TXT" | head -1 | cut -d: -f1)"
+  if [ -z "$q" ] || [ "$opt" -lt "$q" ]; then
+    ok "the decision-room path (line $opt) comes before the first question"
+  else
+    fail "the decision-room path (line $opt) comes after the first question (line $q)"
+  fi
+else
+  ok 'no decision-room path in this answer: the room was not opened, so the order is not scored'
+fi
+
+# The contract is only scored when it was written: with an owner-only item open, nothing freezes.
+if [ -f "$WORK/PLAN.md" ]; then
+  contains "$WORK/PLAN.md" '^## ' 'PLAN.md carries ## sections'
+  if [ -d "$WORK/decisions" ]; then
+    ok 'decisions/ exists beside the frozen PLAN.md'
+  else
+    fail 'PLAN.md was written but decisions/ does not exist'
+  fi
+else
+  ok 'no PLAN.md written — nothing was frozen, so the contract is not scored'
+fi
+
+# The phase plan is never written by this skill.
+no_path "$WORK/phases/01/PLAN.md" 'no phases/NN/PLAN.md was written here'
+
+finish

package/scripts/evals/cases/decide-final-round/case.json

@@ -0,0 +1,8 @@
+{
+  "max_turns": 40,
+  "history": false,
+  "min_pass": 2,
+  "agent": null,
+  "permission_mode": "bypassPermissions",
+  "note": "Prompt is the slash command itself: since 3.0.0 the session never starts a skill from prose (preamble), so a prose prompt only hands the command back. Empty fixture so the LARGE route has nowhere to resume from. The final round is always sent, even when every item was band 2/3, so the counter must appear whether or not PLAN.md was frozen."
+}

package/scripts/evals/cases/decide-final-round/fixture/README.md

@@ -0,0 +1,3 @@
+# reminders
+
+An empty repository. Nothing is planned yet: no PLAN.md, no ROADMAP.md, no PROGRESS.md.

package/scripts/evals/cases/decide-final-round/prompt.txt

@@ -0,0 +1 @@
+/ll-decide project serviço que envia lembretes por e-mail

package/scripts/evals/cases/executor-block/assert.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# The executor returns exactly one block with the seven fields, and the TDD order holds.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")/../../lib" && pwd)/assert.sh"
+
+WORK="$1"; OUT_JSON="$2"; OUT_TXT="$3"
+
+contains "$OUT_TXT" '^### M1'          'the return opens with the ### M1 heading'
+for f in built commits commands deviations questions backlog not_verified; do
+  contains "$OUT_TXT" "^${f}:" "the return carries the field ${f}:"
+done
+
+# TDD order over the whole history: a test(M1) commit exists and precedes the first feat(M1).
+log="$(git -C "$WORK" log --format=%s --reverse)"
+t="$(printf '%s\n' "$log" | grep -n '^test(M1): ' | head -1 | cut -d: -f1)"
+f="$(printf '%s\n' "$log" | grep -n '^feat(M1): ' | head -1 | cut -d: -f1)"
+if [ -n "$t" ] && [ -n "$f" ] && [ "$t" -lt "$f" ]; then
+  ok "git log shows test(M1) at #$t before feat(M1) at #$f"
+else
+  fail "git log does not show a test(M1) commit before a feat(M1) commit (test=${t:-none} feat=${f:-none})"
+fi
+
+# The executor owns no state file.
+base="$(base_sha "$WORK")"
+if [ -n "$base" ]; then
+  touched="$(git -C "$WORK" diff --name-only "$base" HEAD -- PROGRESS.md PLAN.md ROADMAP.md BACKLOG.md decisions)"
+  if [ -z "$touched" ]; then
+    ok 'no state file was committed by the executor'
+  else
+    fail "the executor committed a state file: $(printf '%s' "$touched" | tr '\n' ' ')"
+  fi
+fi
+
+finish

package/scripts/evals/cases/executor-block/case.json

@@ -0,0 +1,8 @@
+{
+  "max_turns": 40,
+  "history": true,
+  "min_pass": 2,
+  "agent": "ll-executor",
+  "permission_mode": "bypassPermissions",
+  "note": "The fixture history already builds M1 (test(M1) then feat(M1)), so the red test passes on its first run and the contract says the executor returns BLOCKED. The case scores the return block, not the code."
+}

package/scripts/evals/cases/executor-block/prompt.txt

@@ -0,0 +1,14 @@
+MILESTONE     M1 — end-to-end tracer
+PLAN          {{WORK}}/phases/07/PLAN.md            (read whole before acting; your entry is the contract)
+CONTEXT       none — no CODE-CONTEXT.md for this phase; use read_first in the plan
+FILES         {{WORK}}/src/a.ts, {{WORK}}/test/a.test.ts
+WAVE          1 of 3 · alone in this wave · previous blocks: {{WORK}}/PROGRESS.md "## Phase 07"
+TDD           yes — behavior cases in PLAN, milestone M1 · test first, commit test(M1) before feat(M1)
+ACCEPTANCE    npm test -- a.test.ts — run from {{WORK}} after the last commit
+MODEL         contract milestone → opus/high
+DEC RESERVED  DEC-0042, DEC-0043  (cite only these ids in questions:; never create a decision)
+INPUTS        {{WORK}}/src/a.ts, {{WORK}}/test/a.test.ts  (checked: exist)
+DO NOT        write PROGRESS/PLAN/ROADMAP/BACKLOG/decisions; commit outside FILES; push; weaken a test;
+              spawn an agent; cd; relative paths; grep a directory that holds a .env
+RETURN        the `### M1` block in your fixed format (built, commits, commands, deviations, questions,
+              backlog, not_verified), at most 1,500 tokens. Nothing before or after it.

package/scripts/evals/cases/goal-autonomous/assert.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# `/ll-goal --autonomous "<objective>"`: one pasted /goal text for the whole delivery,
+# docs/GOAL.md written with `mode: autonomous` and `phase: all`, nothing asked, no skill started.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")/../../lib" && pwd)/assert.sh"
+
+WORK="$1"; OUT_JSON="$2"; OUT_TXT="$3"
+
+contains "$OUT_TXT" '/goal'                   'the answer carries the /goal text to paste'
+# EXECUTION carries `ll-auto` with `--auto-decision`; the objective and `--verify all` may sit
+# between them and the text wraps, so the answer is read flattened.
+if tr '\n' ' ' < "$OUT_TXT" 2>/dev/null | grep -Eq 'll-auto.{0,80}--auto-decision'; then
+  ok 'EXECUTION runs the delivery with ll-auto --auto-decision'
+else
+  fail 'EXECUTION runs the delivery with ll-auto --auto-decision'
+fi
+
+# The pasted block is what the owner copies: from the /goal line to the `▶ Next` line, or to the
+# end when there is none. The goal text is a pointer, never a copy of PLAN.md: it stays small.
+block="$(awk '/\/goal/ { on = 1 } on && /▶ Next/ { exit } on { print }' "$OUT_TXT" 2>/dev/null)"
+n="$(printf '%s' "$block" | wc -c)"
+if [ "$n" -ge 400 ] && [ "$n" -le 4000 ]; then
+  ok "the pasted /goal text measures $n chars (400..4000)"
+else
+  fail "the pasted /goal text measures $n chars, outside 400..4000"
+fi
+
+if [ -f "$WORK/docs/GOAL.md" ]; then ok 'docs/GOAL.md exists in the work tree'
+else fail 'docs/GOAL.md exists in the work tree'; fi
+contains "$WORK/docs/GOAL.md" '^mode: autonomous$' 'docs/GOAL.md frontmatter carries mode: autonomous'
+contains "$WORK/docs/GOAL.md" '^phase: all$'       'docs/GOAL.md frontmatter carries phase: all (the whole delivery)'
+
+no_tool_use "$OUT_JSON" Skill           'no Skill tool call anywhere in the capture'
+no_tool_use "$OUT_JSON" AskUserQuestion 'no AskUserQuestion tool call anywhere in the capture'
+
+finish

package/scripts/evals/cases/goal-autonomous/case.json

@@ -0,0 +1,8 @@
+{
+  "max_turns": 20,
+  "history": false,
+  "min_pass": 1,
+  "agent": null,
+  "permission_mode": "bypassPermissions",
+  "note": "Own fixture, not the shared scripts/fixtures/project: a healthy repo with PLAN.md, ROADMAP.md (07 and 08 PLANNED), a consistent PROGRESS.md board, no phases/NN/PLAN.md yet and `npm test` exit 0. The shared fixture is broken on purpose (plan-lint verdict fail, milestones marked passes: true with no commit, no test runner) and ll-goal step 1 is right to stop there — `a plan that fails there does not become a goal` — so it can never prove the autonomous branch. Proves: one pasted /goal text for the whole delivery with EXECUTION on ll-auto --auto-decision, docs/GOAL.md with `mode: autonomous` and `phase: all` committed, nothing asked and no skill started. max_turns 20 (B-018 rule: above the highest count real reps show — 17 here): the run reads PLAN/ROADMAP/PROGRESS, calls the ll-auto detect helper, writes and commits docs/GOAL.md, and the reported num_turns counts the skill's `!` preprocessor Bash calls together with the model's own tool calls."
+}

package/scripts/evals/cases/goal-autonomous/fixture/PLAN.md

@@ -0,0 +1,42 @@
+# PLAN — reconciliation service
+
+## §0 Precedence
+
+This file is self-contained and the ONLY entry of the work. §2 > §3 > §6 > §7. Decisions in §3 are a
+contract — do not re-litigate. Project CLAUDE.md > this file > phase plans > briefs.
+
+## §1 Objective and truths
+
+Every provider event is reconciled exactly once and every mismatch is visible to the operator.
+
+- T1 A provider batch produces one row per event. — `npm test` exit 0
+- T2 A replayed batch adds no rows. — `npm test` exit 0
+
+Requirements: REQ-k (phase 07), REQ-m (phase 08).
+
+## §2 Invariants
+
+I-01 Never delete, disable or weaken a test or an acceptance criterion. [owner, 2026-08-20]
+I-02 Do not fill a gap with a plausible interpretation: report and ask. [owner, CLAUDE.md]
+
+## §3 Owner decisions
+
+| id | question | decision | by | date | against recommendation? | reversible? |
+|---|---|---|---|---|---|---|
+| DEC-0041 | mismatch unit | cents, integer | owner | 2026-08-22 | no | 1 commit |
+
+## §6 Global acceptance
+
+CA-01 — WHEN a batch is ingested THE SYSTEM SHALL write one row per event · `npm test` exit 0
+CA-02 — WHEN a mismatch is found THE SYSTEM SHALL report it · `npm test` exit 0
+
+## §7 Execution protocol
+
+Models per role: session fable/high · scout sonnet/medium · contract executor opus/high · mechanical
+executor sonnet/medium · verifier opus/high · reviewer opus/medium. Max 3 executors per wave on
+disjoint files. Commit per path after each milestone; push only with everything green (push is not a
+deploy here). TDD on by default; exceptions: config and glue.
+
+## §8 Phases
+
+Phases live in ROADMAP.md. Current phase: 07.

package/scripts/evals/cases/goal-autonomous/fixture/PROGRESS.md

@@ -0,0 +1,20 @@
+# PROGRESS — reconciliation service
+
+<!-- ll-state -->
+phase: 07
+milestones:
+<!-- /ll-state -->
+
+## Rules for all agents
+
+- Only the main session writes this file. Executors return blocks; the session appends them.
+- Never delete, disable or weaken a test or an acceptance criterion.
+- Commit per milestone with `type(Mn): what`.
+
+## Epilogue — phase 06 — 2026-08-30
+
+passed: M1, M2 (2/2) — provider adapters shipped, `npm test` green.
+left: none. waiting: none.
+verification: APPROVED.
+
+## Phase 07

package/scripts/evals/cases/goal-autonomous/fixture/ROADMAP.md

@@ -0,0 +1,29 @@
+# ROADMAP — reconciliation service
+
+| phase | name | depends_on | requirements | state |
+|---|---|---|---|---|
+| 05 | payment intake | — | REQ-a | DONE (docs/history/v1.0) |
+| 06 | provider adapters | 05 | REQ-b | DONE (docs/history/v1.0) |
+| 07 | billing reconciliation | 05, 06 | REQ-k | PLANNED |
+| 08 | reconciliation reporting | 07 | REQ-m | PLANNED |
+
+## Phase 07 — billing reconciliation
+
+Objective: every provider event lands in `billing_events` exactly once and mismatches are visible.
+
+Success criteria:
+- SC-01 The reconciliation job ingests a provider batch and writes one row per event.
+- SC-02 A replayed batch produces no duplicate rows.
+- SC-03 Cent-level mismatches are reported instead of silently dropped.
+
+Deferred ideas: customer portal; accounting export.
+
+## Phase 08 — reconciliation reporting
+
+Objective: the operator reads yesterday's reconciliation without opening the database.
+
+Success criteria:
+- SC-01 A daily report lists ingested, tolerated and rejected rows.
+- SC-02 The report is reachable from the operator console.
+
+Deferred ideas: CSV export.

package/scripts/evals/cases/goal-autonomous/fixture/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "reconciliation-service",
+  "version": "0.6.0",
+  "private": true,
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  }
+}

package/scripts/evals/cases/goal-autonomous/fixture/src/money.js

@@ -0,0 +1,6 @@
+// Cent-level arithmetic: DEC-0041 — money is an integer number of cents.
+function toCents(amount) {
+  return Math.round(Number(amount) * 100);
+}
+
+module.exports = { toCents };

package/scripts/evals/cases/goal-autonomous/fixture/test/reconcile.test.js

@@ -0,0 +1,8 @@
+const test = require('node:test');
+const assert = require('node:assert');
+
+const { toCents } = require('../src/money.js');
+
+test('amounts are compared in integer cents', () => {
+  assert.strictEqual(toCents('10.05'), 1005);
+});

package/scripts/evals/cases/goal-autonomous/prompt.txt

@@ -0,0 +1 @@
+/ll-goal --autonomous "Deliver phases 07 and 08"

package/scripts/evals/cases/implement-review-gate/assert.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# The review gate opens wave 1: PLAN-REVIEW.md exists, and no feat( commit of this run
+# predates it. Only phase 07 is planned.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")/../../lib" && pwd)/assert.sh"
+
+WORK="$1"; OUT_JSON="$2"; OUT_TXT="$3"
+REVIEW="phases/07/PLAN-REVIEW.md"
+
+if [ -f "$WORK/$REVIEW" ]; then
+  ok "$REVIEW exists"
+else
+  fail "$REVIEW does not exist: the gate before wave 1 was not written"
+fi
+
+base="$(base_sha "$WORK")"
+# Only commits this run added count; the fixture history already carries feat( commits.
+range="${base:+$base..HEAD}"
+first_feat="$(git -C "$WORK" log ${range:+"$range"} --reverse --format='%ct %s' | grep -m1 ' feat(' | cut -d' ' -f1)"
+
+if [ -z "$first_feat" ]; then
+  ok 'this run committed no feat(: nothing could precede the gate'
+else
+  # The review is written once by the verifier and committed later with the phase state, so the
+  # earliest evidence dates it: the file mtime, or its commit when that is older.
+  review_ct="$(stat -c %Y "$WORK/$REVIEW" 2>/dev/null)"
+  review_commit="$(git -C "$WORK" log --diff-filter=A --format=%ct -- "$REVIEW" | tail -1)"
+  if [ -n "$review_commit" ] && { [ -z "$review_ct" ] || [ "$review_commit" -lt "$review_ct" ]; }; then review_ct="$review_commit"; fi
+  if [ -n "$review_ct" ] && [ "$review_ct" -le "$first_feat" ]; then
+    ok "the gate ($review_ct) precedes the first feat( of this run ($first_feat)"
+  else
+    fail "a feat( commit at $first_feat precedes the review gate at ${review_ct:-none}"
+  fi
+fi
+
+no_path "$WORK/phases/08" 'nothing was written under phases/08/'
+
+finish

package/scripts/evals/cases/implement-review-gate/case.json

@@ -0,0 +1,8 @@
+{
+  "max_turns": 45,
+  "history": true,
+  "min_pass": 2,
+  "agent": null,
+  "permission_mode": "bypassPermissions",
+  "note": "--no-talk so a one-shot run never waits on an owner-only question: the cents item (DEC-0041) becomes WAITING, M5/M6/M7 get stop: owner, and the review gate must still be written for M1/M2/M4. No executor is dispatched until phases/07/PLAN-REVIEW.md is on disk; and one invocation plans one phase, so phases/08/ must stay untouched."
+}

package/scripts/evals/cases/implement-review-gate/prompt.txt

@@ -0,0 +1 @@
+/ll-implement 7 --no-talk

package/scripts/evals/cases/implement-stops-at-next/assert.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+# "▶ Next" ends the turn: no tool call follows it.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")/../../lib" && pwd)/assert.sh"
+
+WORK="$1"; OUT_JSON="$2"; OUT_TXT="$3"
+
+verdict="$(node -e '
+  const fs = require("fs");
+  let data; try { data = JSON.parse(fs.readFileSync(process.argv[1], "utf8")); }
+  catch { process.stdout.write("unparseable out.json"); process.exit(0); }
+  const events = Array.isArray(data) ? data : [data];
+
+  let nextAt = -1;          // index of the assistant text block carrying the marker
+  let toolAfter = null;     // the first tool_use seen after it
+  events.forEach((ev, i) => {
+    if (!ev || ev.type !== "assistant") return;   // hook context and tool results are not assistant text
+    const content = ev.message && ev.message.content;
+    if (!Array.isArray(content)) return;
+    for (const b of content) {
+      if (!b) continue;
+      if (b.type === "text" && /▶ Next/.test(b.text || "")) { if (nextAt < 0) nextAt = i; }
+      else if (b.type === "tool_use" && nextAt >= 0 && !toolAfter) toolAfter = b.name;
+    }
+  });
+
+  if (nextAt < 0) { process.stdout.write("no assistant text carries the ▶ Next marker"); process.exit(0); }
+  if (toolAfter)  { process.stdout.write("a " + toolAfter + " tool call follows the ▶ Next line"); process.exit(0); }
+  process.stdout.write("");
+' "$OUT_JSON")"
+
+if [ -z "$verdict" ]; then
+  ok 'the ▶ Next line is the last thing the invocation does'
+else
+  fail "$verdict"
+fi
+
+contains "$OUT_TXT" '/clear' 'the next command is handed over with /clear'
+
+# The waves are visible while they run, not only in the epilogue (F-4).
+# The wave line is printed mid-run, so it lives in an earlier assistant text block, not in the final
+# answer: scan the capture in order and map it onto the same scale as the epilogue check.
+onda="$(node -e '
+  const fs = require("fs");
+  let data; try { data = JSON.parse(fs.readFileSync(process.argv[1], "utf8")); } catch { process.exit(0); }
+  const events = Array.isArray(data) ? data : [data];
+  let n = 0, hit = 0, epi = 0;
+  for (const ev of events) {
+    if (!ev || ev.type !== "assistant") continue;
+    const content = ev.message && ev.message.content;
+    if (!Array.isArray(content)) continue;
+    for (const b of content) {
+      if (!b) continue;
+      // a one-shot run prints no mid-run text: the wave heartbeat is the proxy; the screen line is checked by the lab rubric
+      if (b.type === "tool_use" && !hit && /heartbeat\s+\\?"(wave|onda) 1\//.test(JSON.stringify(b.input || {}))) hit = n + 1;
+      if (b.type !== "text") continue;
+      n++;
+      if (!hit && /(^|\n)onda 1\//.test(b.text || "")) hit = n;
+      if (!epi && /## Epilogue|▶ Next/.test(b.text || "")) epi = n;
+    }
+  }
+  if (hit) process.stdout.write(String(hit));
+' "$OUT_JSON")"
+close_block="$(node -e '
+  const fs = require("fs");
+  let data; try { data = JSON.parse(fs.readFileSync(process.argv[1], "utf8")); } catch { process.exit(0); }
+  const events = Array.isArray(data) ? data : [data];
+  let n = 0;
+  for (const ev of events) {
+    if (!ev || ev.type !== "assistant") continue;
+    const content = ev.message && ev.message.content;
+    if (!Array.isArray(content)) continue;
+    for (const b of content) {
+      if (!b || b.type !== "text") continue;
+      n++;
+      if (/## Epilogue|▶ Next/.test(b.text || "")) { process.stdout.write(String(n)); process.exit(0); }
+    }
+  }
+' "$OUT_JSON")"
+close="$(grep -nE '^## Epilogue|▶ Next' "$OUT_TXT" | head -1 | cut -d: -f1)"
+if [ -z "$onda" ]; then
+  fail 'no "onda 1/M" line: the first wave ran with no visible progress'
+elif [ -n "$close_block" ] && [ "$onda" -gt "$close_block" ]; then
+  fail "the onda 1/M line (text block $onda) comes only after the epilogue (text block $close_block)"
+else
+  ok "the first wave is announced on screen (line $onda), before the epilogue"
+fi
+
+# The helper is called, never read (F-7): no shell that cats/seds/greps it, no Read of it.
+reads="$(node -e '
+  const fs = require("fs");
+  let data; try { data = JSON.parse(fs.readFileSync(process.argv[1], "utf8")); }
+  catch { process.stdout.write("unparseable out.json"); process.exit(0); }
+  const events = Array.isArray(data) ? data : [data];
+  const shell = /(^|[\s;|&(])(cat|sed|grep|head|tail|less)\b[^\n;|&]*ll-tools\.js/; // the reading verb starts a command and the helper is its argument
+  for (const ev of events) {
+    if (!ev || ev.type !== "assistant") continue;
+    const content = ev.message && ev.message.content;
+    if (!Array.isArray(content)) continue;
+    for (const b of content) {
+      if (!b || b.type !== "tool_use") continue;
+      const input = b.input || {};
+      if (b.name === "Bash" && shell.test(String(input.command || ""))) {
+        process.stdout.write("a Bash call reads the helper: " + String(input.command).slice(0, 80));
+        process.exit(0);
+      }
+      if (b.name === "Read" && /ll-tools\.js$/.test(String(input.file_path || ""))) {
+        process.stdout.write("a Read call opens the helper: " + String(input.file_path));
+        process.exit(0);
+      }
+    }
+  }
+  process.stdout.write("");
+' "$OUT_JSON")"
+
+if [ -z "$reads" ]; then
+  ok 'the helper was called, never read'
+else
+  fail "$reads"
+fi
+
+finish

package/scripts/evals/cases/implement-stops-at-next/case.json

@@ -0,0 +1,9 @@
+{
+  "max_turns": 30,
+  "history": true,
+  "min_pass": 2,
+  "agent": null,
+  "permission_mode": "bypassPermissions",
+  "reuse": "implement-review-gate",
+  "note": "Scores the same capture as implement-review-gate — no second claude call. Run both cases together, or this one reports the missing source."
+}

package/scripts/evals/cases/implement-stops-at-next/prompt.txt

@@ -0,0 +1 @@
+/ll-implement 7 --no-talk

package/scripts/evals/cases/preamble-no-ritual/assert.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# The typo is fixed and no ceremony file is born.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")/../../lib" && pwd)/assert.sh"
+
+WORK="$1"; OUT_JSON="$2"; OUT_TXT="$3"
+
+contains "$WORK/src/a.ts" 'receive' 'src/a.ts now spells receive'
+absent   "$WORK/src/a.ts" 'recieve' 'no occurrence of the typo is left'
+
+no_path "$WORK/PROGRESS.md"     'no PROGRESS.md was created'
+no_path "$WORK/VERIFICATION.md" 'no VERIFICATION.md was created'
+no_path "$WORK/phases"          'no phases/ was created'
+no_path "$WORK/PLAN.md"         'no PLAN.md was created'
+
+no_tool_use "$OUT_JSON" Skill 'no Skill tool call anywhere in the capture'
+
+finish

package/scripts/evals/cases/preamble-no-ritual/case.json

@@ -0,0 +1,8 @@
+{
+  "max_turns": 6,
+  "history": false,
+  "min_pass": 2,
+  "agent": null,
+  "permission_mode": "bypassPermissions",
+  "note": "SMALL forbids the ritual: no spec, no plan, no PROGRESS, no VERIFICATION, no subagent for what fits in three calls, and no skill started on the session's behalf."
+}

package/scripts/evals/cases/preamble-no-ritual/fixture/README.md

@@ -0,0 +1,3 @@
+# events
+
+One module. One typo.

package/scripts/evals/cases/preamble-no-ritual/fixture/src/a.ts

@@ -0,0 +1,3 @@
+export function recieveEvent(id: string): string {
+  return `recieved:${id}`;
+}

package/scripts/evals/cases/preamble-no-ritual/prompt.txt

@@ -0,0 +1 @@
+corrige o typo 'recieve' em src/a.ts

package/scripts/evals/cases/router-no-skill/assert.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# A skill runs only when the owner types it: a plain research request is answered here and
+# now — no command handed back to paste, no ▶ Next, no Skill tool call — even though the
+# fixture carries ll-skills state (PLAN.md, decisions/).
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")/../../lib" && pwd)/assert.sh"
+
+WORK="$1"; OUT_JSON="$2"; OUT_TXT="$3"
+
+# The queue engines a real answer names. Longest alternative first: grep -E is leftmost-longest,
+# so "bullmq" never scores as "bull".
+QUEUES='bullmq|bee-queue|pg-boss|rabbitmq|graphile|bull|redis|sqs|kafka|agenda'
+
+absent "$OUT_TXT" '▶ Next' 'the answer ends in no ▶ Next: this turn is not a skill hand-off'
+
+if [ -f "$OUT_TXT" ] && grep -Eqi -- 'cole:|cole isto|cole o comando|paste this' "$OUT_TXT"; then
+  fail "the answer hands a command back to paste: $(grep -Eio -- 'cole:|cole isto|cole o comando|paste this' "$OUT_TXT" | head -1)"
+else
+  ok 'the answer hands no command back to paste'
+fi
+
+n="$(grep -Eoi -- "$QUEUES" "$OUT_TXT" 2>/dev/null | tr 'A-Z' 'a-z' | sort -u | wc -l)"
+if [ "${n:-0}" -ge 2 ]; then
+  ok "the research was done here: $n queue options named"
+else
+  fail "the answer names $n queue option(s): the research was not done"
+fi
+
+no_tool_use "$OUT_JSON" Skill 'no Skill tool call anywhere in the capture'
+
+no_path "$WORK/PROGRESS.md" 'no PROGRESS.md was created'
+no_path "$WORK/phases"      'no phases/ was created'
+
+finish

package/scripts/evals/cases/router-no-skill/case.json

@@ -0,0 +1,8 @@
+{
+  "max_turns": 8,
+  "history": false,
+  "min_pass": 2,
+  "agent": null,
+  "permission_mode": "acceptEdits",
+  "note": "A skill runs only when the owner types it. A plain request is done as asked, never handed back as a command to paste — and the fixture carries ll-skills state (PLAN.md, decisions/) to prove the claim where a router would be loudest. No PROGRESS.md, so nothing competes with the answer. max_turns 8 leaves room for a couple of reads before the answer."
+}

package/scripts/evals/cases/router-no-skill/fixture/PLAN.md

@@ -0,0 +1,21 @@
+# PLAN — now
+
+## §0 Precedence
+
+This file is the entry of the work; the project CLAUDE.md wins over it.
+
+## §1 Objective and truths
+
+One sentence of delivery: the CLI prints the local time and exits 0.
+
+- T1 `node now.js` prints one line and exits 0. — `node now.js`
+
+## §2 Invariants
+
+I-01 NEVER delete, disable or weaken a test or acceptance criterion. [owner]
+
+## §3 Owner decisions
+
+| id | question | decision | by | date |
+|---|---|---|---|---|
+| — | none recorded yet | — | — | — |

package/scripts/evals/cases/router-no-skill/fixture/README.md

@@ -0,0 +1,7 @@
+# now
+
+A tiny CLI that prints the time.
+
+## Run
+
+    node now.js