@event4u/agent-config 10.1.0 → 10.3.0

package/src/scripts/conformance_scan.ts

@@ -6,17 +6,31 @@
  * The scope constraint is the point, and it is a council ruling
  * (2026-08-06): *"a conformance scan that checks un-mechanised rules is
  * theatre — if you can't gate it, don't pretend measuring it post-hoc is
- * enforcement."* So this scan carries exactly four checks, one per shipped
- * gate, and every classifier is IMPORTED from the gate it measures rather than
- * re-implemented here. A second copy of a classifier is the "second artefact to
- * keep in sync" the repo's own principle forbids, and it would let the scan and
- * the gate disagree silently.
+ * enforcement."* So every classifier is IMPORTED from the gate it measures
+ * rather than re-implemented here. A second copy of a classifier is the "second
+ * artefact to keep in sync" the repo's own principle forbids, and it would let
+ * the scan and the gate disagree silently.
  *
  *   language-pin      ← language_mirror_hook.classify
  *   git-authorization ← git_authorization_hook.classifyAuthorization
  *                       + block_unauthorized_git.commandOp / BLOCK_OPS
  *   vacuous-evidence  ← before_complete_hook.isVacuousOutput / isCiPoll / pendingCount
  *   evidence-steering ← evidence_independence.isEvaluationPrompt / preloadedVerdict
+ *   completion-claim  ← turn_end_gate_hook.detectCompletionClaim          (round 7)
+ *   task-completeness ← delegation_nudge_hook.enumeratedFileTokens /
+ *                       FILE_SIGNAL_FLOOR                                (below)
+ *
+ * The count was "exactly four checks, one per shipped gate" and both halves have
+ * since moved, so both are stated plainly rather than left to rot: there are
+ * SIX, and `task-completeness` is the one with NO gate behind it. That is not a
+ * quiet exception to the council ruling — it is the ruling's own logic run
+ * forwards. The ruling forbids presenting a post-hoc measurement AS enforcement;
+ * this check exists to decide whether a refusal is warranted at all, before one
+ * is built, because the alternative is a gate resting on an unmeasured premise.
+ * The pre-registered bar it will be read against is committed BEFORE the number
+ * (`road-to-completion-loop` Phase 2), and a published null — no gate — is an
+ * accepted outcome. Nothing here claims the check enforces anything: this file
+ * is a REPORT, as its exit contract below says.
  *
  * Deliberately NOT scanned: ask-shape, session-canary, promissory closings,
  * checkbox batching, symptom-vs-root-cause. Those are left as prose by
@@ -34,6 +48,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { censusRuleDir } from "./_lib/carrier_divergence.js";
+import { projectStoreSlug } from "./_lib/cc_transcript.js";
 import { entryText, isSidechain } from "./_lib/transcript_entry.js";
 
 import { classify } from "./language_mirror_hook.js";
@@ -45,6 +60,10 @@ import { isVacuousOutput, isCiPoll, pendingCount } from "./before_complete_hook.
 // than reimplemented, so the measured rate and the gate cannot disagree.
 import { detectCompletionClaim } from "./hooks/turn_end_gate_hook.js";
 import { isEvaluationPrompt, isSelfScoped, preloadedVerdict } from "./hooks/evidence_independence.js";
+// Phase 1 of `road-to-completion-loop` — the SAME prompt-signal extraction the
+// delegation nudge classifies on, so the measurement cannot see a different
+// deliverable set than the classifier does.
+import { enumeratedFileTokens, FILE_SIGNAL_FLOOR } from "./hooks/delegation_nudge_hook.js";
 
 /**
  * This module's own repo root, NOT `process.cwd()`.
@@ -65,7 +84,8 @@ export interface Violation {
     | "git-authorization"
     | "vacuous-evidence"
     | "evidence-steering"
-    | "completion-claim";
+    | "completion-claim"
+    | "task-completeness";
   session: string;
   at: string;
   detail: string;
@@ -79,6 +99,19 @@ export interface Violation {
    */
   turns_since_prompt?: number;
   compaction_since_prompt?: boolean;
+  /**
+   * `task-completeness` only. The deliverable set's size, how many of it the
+   * reply window touched, and the tokens it never touched.
+   *
+   * Structured rather than prose-only because 1.3 requires HAND-VALIDATING every
+   * hit: a validator needs the exact missed tokens to open the window and decide
+   * whether the omission was real or one of the legitimate shapes (a blocking
+   * question, a hand-back, a user-fenced scope, an explicitly deferred item).
+   * A count alone cannot be checked, which is the failure this field prevents.
+   */
+  enumerated?: number;
+  addressed?: number;
+  missed?: string[];
 }
 
 export interface SessionReport {
@@ -97,6 +130,18 @@ export interface SessionReport {
   de_pin_turns: number;
   /** First entry timestamp, so a reader can era-split without a second pass. */
   first_at: string;
+  /**
+   * `task-completeness`'s DENOMINATOR: reply windows that met the file floor and
+   * contained real assistant work, i.e. the windows on which the check could fire
+   * at all.
+   *
+   * Counted here beside the numerator for the same reason `de_pin_turns` is — a
+   * rate whose two halves are derived from different populations is the defect
+   * round 7 § 6.2 found in the language figure, where the same 152 violations read
+   * 6.5 % over all turns and 9.2 % over the eligible ones. Without this a hit
+   * COUNT is all there is, and a count is not a rate.
+   */
+  completeness_windows: number;
 }
 
 /**
@@ -177,6 +222,17 @@ export interface RateRecord {
   de_pin_turns?: number;
   /** The same numerator over `de_pin_turns`. Reported beside `rate_pct`, never instead. */
   rate_pct_de_pin?: number;
+  /**
+   * `task-completeness`'s two halves, optional for the same archive reason as the
+   * four above: no line written before this check existed carries them.
+   *
+   * The rate is over WINDOWS, not turns or sessions — the only denominator on
+   * which the check can fire — and it is persisted beside the count so a later
+   * reader cannot mistake a hit count for a rate.
+   */
+  completeness_windows?: number;
+  task_completeness?: number;
+  task_completeness_rate_pct?: number;
   /** The corpus straddles a carrier landing, so no band verdict. */
   era_spanning?: boolean;
   /** Which carrier, when `era_spanning` — empty otherwise. */
@@ -265,6 +321,7 @@ export const CHECK_IDS: readonly CheckId[] = [
   "vacuous-evidence",
   "evidence-steering",
   "completion-claim",
+  "task-completeness",
 ];
 
 /**
@@ -297,6 +354,36 @@ export const CHECK_MEANINGS: Record<CheckId, string> = {
     "each followed by the user handing the work back; this is the same " +
     "predicate `turn-end-gate`'s completion detector refuses on, so the rate " +
     "and the gate cannot disagree. A session that never polled CI can never hit.",
+  "task-completeness":
+    "A reply window that left at least one file the prompt ENUMERATED " +
+    "untouched — the token appears in neither any tool-call input nor any " +
+    "assistant prose before the next user prompt. Scope is deliberately narrow: " +
+    `only prompts naming >= ${FILE_SIGNAL_FLOOR} distinct file tokens are ` +
+    "measured, the same floor `delegation_nudge_hook` uses for its FILE shape, " +
+    "and the token list comes from that module rather than a second regex.\n" +
+    "    What distinguishes a hit from a false read: a hit is EVIDENCE OF AN " +
+    "OMISSION, not proof of one. Four legitimate shapes produce the same " +
+    "signature and are NOT excluded here — a blocking question, a hand-back, a " +
+    "user-fenced scope, and an explicitly deferred item all address fewer files " +
+    "than the prompt named, correctly. That is why every hit is hand-validated " +
+    "and a precision is published beside the rate; an unvalidated count from " +
+    "this check means nothing.\n" +
+    "    What it cannot see, stated so a zero is not misread as health: the " +
+    "ordered-plan, explicit-count, for-each and conjunction shapes name a " +
+    "COUNT of deliverables but not their identities, so this check is blind to " +
+    "them by construction — it does not score them complete, it does not score " +
+    "them at all. A prose deliverable that is not a filename is invisible to it.\n" +
+    "    MEASURED PRECISION: 0 of 3 hits, over 4 eligible windows in 28 sessions " +
+    "(2026-08-12). All three were false positives from ONE extraction defect: the " +
+    "token list is taken from the whole prompt, so files quoted inside material " +
+    "the user PASTED — a review, a log, an example — read as deliverables. In all " +
+    "three, the user's own ask contributed zero tokens. `isInjectedBody` did not " +
+    "filter them because it only excludes long ENGLISH text, and this corpus is " +
+    "mostly German (12 295 and 7 656 chars, both classified `de`, both passed); " +
+    "the one English case missed the 2 500-char cut by 12. So a hit here is not " +
+    "evidence of anything until the ask is separated from the pasted material. " +
+    "Detector D was NOT built on this result — see " +
+    "`agents/evidence/analysis/task-completeness-measurement.md`.",
 };
 
 /**
@@ -333,6 +420,18 @@ export function renderWhy(report: ScanReport, id: CheckId): string {
           `compaction_since_prompt=${compacted ?? "—"}`,
       );
     }
+    // `task-completeness` provenance. Printed as its own line because 1.3
+    // requires hand-validating every hit, and a validator needs the missed
+    // tokens verbatim — not a truncated detail string.
+    const missed = (v as { missed?: string[] }).missed;
+    if (missed !== undefined) {
+      const enumerated = (v as { enumerated?: number }).enumerated;
+      const addressed = (v as { addressed?: number }).addressed;
+      lines.push(
+        `      provenance: enumerated=${enumerated ?? "—"} · ` +
+          `addressed=${addressed ?? "—"} · missed=[${missed.join(", ")}]`,
+      );
+    }
   }
   return lines.join("\n");
 }
@@ -418,6 +517,54 @@ export const HARNESS_TEXT =
 const EN_OPENER =
   /^(let me|i'?ll |i'?m |found it|ok[,. ]|okay|alright|here'?s|now[,. ]|looking|checking|reading|running|the |this |that |there |we |you |good |right[,. ]|perfect|done[.,]|all |confirmed|correct)/i;
 
+/**
+ * One prompt's reply window, for the `task-completeness` check.
+ *
+ * A "turn" in this store is one ENTRY, and a single reply spans several of them
+ * (one prose entry plus one per tool call). Scoring per entry would report every
+ * tool-call entry as incomplete, so the unit is the window from a counted user
+ * prompt to the next one — which is what step 1.1's "the turn's own user prompt"
+ * means in the transcript's actual shape. The departure is recorded rather than
+ * silently taken.
+ */
+export interface CompletenessWindow {
+  /** The PROMPT's timestamp, not an assistant entry's: it is where a validator opens the window. */
+  at: string;
+  tokens: string[];
+  addressed: Set<string>;
+  /**
+   * The window contained at least one assistant prose entry or tool call.
+   *
+   * An empty window is a truncated or abandoned session, not an omission — and
+   * counting it would make the rate a measure of how often a store ends
+   * mid-reply. That is the "detector reproduces the defect it measures" trap
+   * this check's own risk register names.
+   */
+  worked: boolean;
+}
+
+/** Mark every deliverable token this text mentions as addressed. */
+export function markAddressed(text: string, w: CompletenessWindow): void {
+  if (w.tokens.length === 0) {
+    return;
+  }
+  const hay = text.toLowerCase();
+  for (const t of w.tokens) {
+    if (!w.addressed.has(t) && hay.includes(t)) {
+      w.addressed.add(t);
+    }
+  }
+}
+
+/** The window's verdict: the untouched tokens, or `null` for no finding. */
+export function evaluateWindow(w: CompletenessWindow): { missed: string[] } | null {
+  if (!w.worked || w.tokens.length === 0) {
+    return null;
+  }
+  const missed = w.tokens.filter((t) => !w.addressed.has(t));
+  return missed.length > 0 ? { missed } : null;
+}
+
 export function scanSession(sessionId: string, lines: string[]): SessionReport {
   const report: SessionReport = {
     session: sessionId,
@@ -426,6 +573,7 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
     violations: [],
     de_pin_turns: 0,
     first_at: "",
+    completeness_windows: 0,
   };
 
   let pinned: "de" | "en" | null = null;
@@ -443,6 +591,44 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
   // measured failure is a completion claim in a LATER turn than the poll.
   let ciSeen = false;
   let ciSettled = false;
+  // Phase 1 of `road-to-completion-loop` — the open reply window, or null when
+  // the last prompt named no deliverable set worth scoring.
+  let openWindow: CompletenessWindow | null = null;
+
+  /**
+   * Close the open window and record a finding if anything went untouched.
+   * Called on the NEXT counted prompt and once after the loop — a window left
+   * open at end-of-file is the most common shape in a live store and dropping it
+   * would silently bias the rate toward long sessions.
+   */
+  const closeWindow = (): void => {
+    if (openWindow === null) {
+      return;
+    }
+    // The denominator counts windows the check COULD fire on. A window with no
+    // assistant work is excluded from both halves — `evaluateWindow` already
+    // refuses to score it, and counting it below while never counting it above
+    // would deflate the rate by however often a store ends mid-reply.
+    if (openWindow.worked) {
+      report.completeness_windows += 1;
+    }
+    const verdict = evaluateWindow(openWindow);
+    if (verdict !== null) {
+      const addressed = openWindow.tokens.length - verdict.missed.length;
+      report.violations.push({
+        check: "task-completeness",
+        session: sessionId,
+        at: openWindow.at,
+        detail:
+          `prompt enumerated ${openWindow.tokens.length} file(s), reply window touched ` +
+          `${addressed}; untouched: ${verdict.missed.join(", ").slice(0, 160)}`,
+        enumerated: openWindow.tokens.length,
+        addressed,
+        missed: verdict.missed,
+      });
+    }
+    openWindow = null;
+  };
 
   for (const line of lines) {
     if (!line.trim()) {
@@ -516,6 +702,21 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
         continue;
       }
       report.user_turns += 1;
+      // Phase 1 — the previous window ends HERE, at the next real chat message.
+      // Ordered deliberately before the new window opens: the filters above
+      // (`isCompactSummary`, `isSyntheticPrompt`, `isInjectedBody`) all `continue`
+      // without closing, which is correct — an injected skill body does not end
+      // the user's reply window.
+      closeWindow();
+      const deliverables = enumeratedFileTokens(ut);
+      if (deliverables.length >= FILE_SIGNAL_FLOOR) {
+        openWindow = {
+          at: String(entry["timestamp"] ?? ""),
+          tokens: deliverables,
+          addressed: new Set<string>(),
+          worked: false,
+        };
+      }
       turnsSincePrompt = 0;
       compactionSincePrompt = false;
       const c = classify(ut);
@@ -538,6 +739,18 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
     if (prose !== null) {
       report.assistant_turns += 1;
       turnsSincePrompt += 1;
+      const firstLine = (prose.split("\n").find((l) => l.trim()) ?? "").trim();
+      // Phase 1 — prose is half the window's evidence (tool inputs are the other
+      // half, marked below). Placed before the language block for the same reason
+      // the completion-claim check is: that block `continue`s on a harness banner,
+      // and evidence collected after it would be skipped without saying so.
+      // A harness retry banner is not the assistant writing, so it marks nothing
+      // AND does not make the window count as worked — otherwise a session that
+      // died on a 529 would read as an omission.
+      if (openWindow !== null && !HARNESS_TEXT.test(firstLine)) {
+        openWindow.worked = true;
+        markAddressed(prose, openWindow);
+      }
       // Round 7 § 6.2 — the denominator the language check can actually fire on.
       // Counted here, beside the numerator, so the two cannot be derived from
       // different populations later.
@@ -578,6 +791,15 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
     }
 
     for (const tu of toolUses(entry)) {
+      // Phase 1 — the other half of the window's evidence. Serialised whole
+      // rather than field-picked: a deliverable can be named in `file_path`,
+      // `command`, `pattern`, `old_string` or a prompt, and enumerating the
+      // fields that count is how a reader of `file_path` alone would score a
+      // `grep`-then-`sed` edit as untouched.
+      if (openWindow !== null) {
+        openWindow.worked = true;
+        markAddressed(`${tu.name} ${JSON.stringify(tu.input)}`, openWindow);
+      }
       const cmd =
         typeof tu.input["command"] === "string" ? (tu.input["command"] as string) : null;
       if (cmd !== null) {
@@ -628,6 +850,11 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
     }
   }
 
+  // The last prompt's window never sees a following prompt, so it is closed
+  // here. Dropping it would bias the rate toward sessions that happen to end on
+  // a user turn.
+  closeWindow();
+
   return report;
 }
 
@@ -644,10 +871,27 @@ export const DEFAULT_RATE_SERIES = path.join(
   "conformance-rates.jsonl",
 );
 
-/** Default Claude Code transcript store for a project directory. */
+/**
+ * Default Claude Code transcript store for a project directory.
+ *
+ * Claude Code slugs every character outside `[A-Za-z0-9-]`, not just the
+ * separator and the dot: `/Users/x/.claude` → `-Users-x--claude`, and a
+ * worktree named `feat+turn-end-gate-always-on` → `feat-turn-end-gate-always-on`.
+ *
+ * The narrower `[/.]` this replaced is why the 2026-08-12 session audit could
+ * not scan the worktree it was running in: the `+` survived into the computed
+ * slug, no such directory exists, and the scan printed "no transcript store"
+ * and measured NOTHING. A measurement tool that silently reports an empty
+ * corpus for a whole class of paths is worse than one that errors, because the
+ * zero is indistinguishable from a clean result.
+ *
+ * The character class is generalised rather than extended by one `+` because
+ * every one of the 56 store names on this machine matches `^[A-Za-z0-9-]+$` —
+ * there is no observed counter-example of a preserved special character, and
+ * guessing which OTHER character is next would repeat this defect.
+ */
 export function defaultStore(projectDir: string): string {
-  // Claude Code slugs BOTH separators and dots: /Users/x/.claude → -Users-x--claude.
-  const slug = projectDir.replace(/[/.]/g, "-");
+  const slug = projectStoreSlug(projectDir);
   return path.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
 }
 
@@ -742,6 +986,16 @@ export function scanStore(store: string, limit: number): ScanReport {
   const de_pin_turns = per_session.reduce((n, s) => n + s.de_pin_turns, 0);
   const rate_pct_de_pin =
     de_pin_turns === 0 ? 0 : Number(((100 * language_pin) / de_pin_turns).toFixed(1));
+  // `task-completeness` over its own denominator. Kept separate from the language
+  // rate on purpose: the two checks fire on different populations, and a single
+  // `rate_pct` covering both would be the pooled figure round 7 § 6.1 had to
+  // retract.
+  const completeness_windows = per_session.reduce((n, s) => n + s.completeness_windows, 0);
+  const task_completeness = totals["task-completeness"] ?? 0;
+  const task_completeness_rate_pct =
+    completeness_windows === 0
+      ? 0
+      : Number(((100 * task_completeness) / completeness_windows).toFixed(1));
   const era = spansCarrierChange(per_session.map((s) => s.first_at));
   const delivered = measureDelivered(
     path.join(REPO_ROOT, ".claude", "rules"),
@@ -764,6 +1018,9 @@ export function scanStore(store: string, limit: number): ScanReport {
       rate_pct,
       de_pin_turns,
       rate_pct_de_pin,
+      completeness_windows,
+      task_completeness,
+      task_completeness_rate_pct,
       era_spanning: era.spans,
       era_reason: era.what,
       band: bandVerdict(rate_pct, assistant_turns, { spansCarrier: era.spans }),
@@ -848,6 +1105,22 @@ export function render(report: ScanReport): string {
     );
     lines.push('    is the comparable one and the second is the honest one. Both are printed.');
   }
+  // `task-completeness`, on its own denominator. Optional-read for the same
+  // archive reason as the two above: a `rate` block recorded before this check
+  // existed carries neither field, and the series exists to be read back.
+  const cWindows = report.rate.completeness_windows;
+  const cRate = report.rate.task_completeness_rate_pct;
+  if (typeof cWindows === "number" && typeof cRate === "number") {
+    lines.push("");
+    lines.push(
+      `  task-completeness  ${cRate.toFixed(1)}%  ` +
+        `(${report.rate.task_completeness ?? 0} of ${cWindows} eligible reply windows)`,
+    );
+    lines.push("    A hit is EVIDENCE of an omission, never proof: a blocking question, a");
+    lines.push("    hand-back, a fenced scope and a deferred item all produce this signature");
+    lines.push("    correctly. Read the hand-validated precision beside this figure or not");
+    lines.push("    at all — `--why task-completeness` lists every hit with its missed tokens.");
+  }
   if (report.rate.band === "era-spanning") {
     lines.push(
       `    Not compared: the corpus SPANS a carrier landing — ${report.rate.era_reason || 'see CARRIER_CHANGES'}.`,

package/src/scripts/cost/track.mjs

@@ -116,10 +116,16 @@ function dedupKey(rec) {
   return `${id} ${reqId}`;
 }
 
-// Claude Code encodes BOTH separators and dots: `/x/.claude/y` → `-x--claude-y`.
-// Replacing only `/` never resolves a dotted path segment, so any cwd under
-// `.claude/worktrees/` silently missed its project dir and exited 2.
-function encodeProjectPath(cwd) { return cwd.replace(/[/.]/g, '-'); }
+// Claude Code slugs every character outside [A-Za-z0-9-], not just separators
+// and dots: `/x/.claude/y` → `-x--claude-y`, and `feat+wt` → `feat-wt`.
+//
+// This is an inline copy of `_lib/cc_transcript.projectStoreSlug` — a module
+// boundary, not an oversight: this file imports node builtins only. Keep the
+// two in step. It was narrowed twice for the same reason (first `/` alone
+// missed dotted segments; then `[/.]` missed a `+` worktree and silently
+// resolved no project dir at all), which is why the class is now closed rather
+// than extended one character per incident.
+function encodeProjectPath(cwd) { return cwd.replace(/[^A-Za-z0-9-]/g, '-'); }
 
 function findProjectDir(cwd) {
   const c = join(PROJECTS_DIR, encodeProjectPath(cwd));

package/src/scripts/council_cli.ts

@@ -777,7 +777,17 @@ function _postRunQuorum(
  * "attendance is telemetry, never a silent drop" applies to the estimate
  * preview too, not only to a completed pass.
  */
-function _format_quorum_line(q: QuorumResult): string {
+function _format_quorum_line(q: QuorumResult, phase?: QuorumEventPhase): string {
+    // The phase tag is not decoration. A degraded run prints attendance TWICE —
+    // the pre-run reading before the estimate table, the post-run reading after
+    // the consult — and the two disagree by construction: `2/2 present …
+    // concluded` then `0/2 present … INCONCLUSIVE`. Same prefix, opposite
+    // content, and until 2026-08-12 neither line said which was which, so an
+    // operator skimming (or anything grepping `council:quorum ·`) could take the
+    // stale one. The event log had solved this from the start with an explicit
+    // `phase` field; stdout had not. Optional, because the estimate path prints
+    // exactly one line and a tag there would claim a distinction it does not make.
+    const tag = phase === undefined ? '' : `${phase === 'pre_run' ? 'before the run' : 'after the run'} · `;
     const verdict = q.status === 'concluded' ? 'concluded' : 'INCONCLUSIVE — release gate holds';
     // Round 7 § 5.3 — a degraded pass says so. `1/2 present, needed 1 —
     // concluded` is literally true and reads as agreement; with a threshold of 1
@@ -786,7 +796,7 @@ function _format_quorum_line(q: QuorumResult): string {
     // what was missing is the word that stops a reader inferring convergence.
     const degraded =
         q.present < q.total ? `  ⚠️  DEGRADED — ${String(q.total - q.present)} member(s) did not answer; this is not convergence.` : '';
-    return `council:quorum · ${q.present}/${q.total} present, needed ${q.threshold} — ${verdict}.${degraded}`;
+    return `council:quorum · ${tag}${q.present}/${q.total} present, needed ${q.threshold} — ${verdict}.${degraded}`;
 }
 
 function build_members(settings: Dict, opts: BuildMembersOptions = {}): ExternalAIClient[] {
@@ -2621,7 +2631,9 @@ function cmd_run(
         _stdout(format_install_hints(skipped) + '\n');
     }
     if (quorum_out.result !== null) {
-        _stdout(_format_quorum_line(quorum_out.result) + '\n');
+        // Tagged, because `cmd_run` prints attendance a SECOND time after the
+        // consult and on a degraded pass the two readings contradict each other.
+        _stdout(_format_quorum_line(quorum_out.result, 'pre_run') + '\n');
     }
     _stdout(
         format_estimate_table(billable, estimates, {
@@ -2777,6 +2789,19 @@ function cmd_run(
         lens: question.mode,
         invocation: String(_getattr(args, 'invocation', 'agent')),
     });
+    // The post-run reading also has to REACH THE OPERATOR, not just the event
+    // log and the payload. Measured 2026-08-12: a pass where BOTH members
+    // errored printed `2/2 present, needed 1 — concluded` — the pre-run banner
+    // from the estimate block above — then `wrote …json`, and nothing else. The
+    // payload said `{status: "inconclusive", present: 0}` and the absent list
+    // named both, so the record was honest the whole time; the only place the
+    // failure was invisible was the stream the operator actually reads. Printing
+    // it unconditionally, rather than only when it differs from the pre-run
+    // value, is deliberate: "attendance is telemetry, never a silent drop"
+    // (`_format_quorum_line`) reads the same way for an unchanged reading, and a
+    // conditional print would make the absence of a line mean two different
+    // things.
+    _stdout(_format_quorum_line(post_run.quorum, 'post_run') + '\n');
     // Phase 4.1 — verdict → handoff envelope. Same tally `render()` computes
     // internally for the Vote Tally block (mirrored here, not imported from
     // there, because `render()` re-derives it from the SAVED payload on a
@@ -4024,5 +4049,10 @@ export {
     _parse_siblings_overrides,
     _synthesize_ai_council_block,
     _postRunQuorum,
+    // Exported for the phase-tag test only. The two-contradictory-banners shape
+    // it guards cannot be produced through `cmd_run` with an injected roster
+    // (the pre-run print is gated on `build_members` having populated
+    // `quorum_out`), and constructing a real roster would spend money.
+    _format_quorum_line,
     CouncilDisabledError,
 };

package/src/scripts/design_slop_rules.test.ts

@@ -100,16 +100,11 @@ const FIXTURES: Record<string, { ext: string; positive: string; negative: string
     negative:
       '<h1>Get Started</h1><p>Deploys are marked ✅ when healthy.</p><td>✅</td><button>Track progress</button>',
   },
-  "slop-lock-shape": {
+  "slop-v8-lock-shape": {
     ext: "css",
     positive: ".a{border-radius:4px}.b{border-radius:8px}.c{border-radius:12px}.d{border-radius:20px}",
     negative: ".a{border-radius:8px}.b{border-radius:12px}",
   },
-  "slop-lock-colour": {
-    ext: "css",
-    positive: ".a{color:#e11d48}.b{background:#2563eb}.c{border-color:#16a34a}",
-    negative: ".a{color:#111827}.b{background:#6b7280}.c{border-color:#2563eb}",
-  },
   "slop-l9-section-monotony": {
     ext: "html",
     // 8 identical media+text sections → 1 distinct layout family (< 4)
@@ -129,6 +124,42 @@ const FIXTURES: Record<string, { ext: string; positive: string; negative: string
     // only 2 consecutive → within cap
     negative: '<section><div class="grid"><img src="x"><h2>A</h2><p>t</p></div></section>'.repeat(2),
   },
+  "slop-v4-over-rounded": {
+    ext: "css",
+    // 24px radius on an 80px chip — mid-range rounding on a small surface
+    positive: ".chip{width:80px;border-radius:24px;background:#1f5f9c}",
+    // a deliberate pill is a shape decision, not over-rounding
+    negative: ".chip{width:80px;border-radius:9999px;background:#1f5f9c}",
+  },
+  "slop-c3-dark-glow": {
+    ext: "css",
+    // zero-offset saturated glow inside a declared dark surface
+    positive: ".dark .btn{background:#0b0f14;box-shadow:0 0 18px #22d3ee}",
+    // same dark surface, ordinary offset depth — not a glow
+    negative: ".dark .btn{background:#0b0f14;box-shadow:0 2px 8px #22d3ee}",
+  },
+  "slop-t9-uppercase-body": {
+    ext: "css",
+    positive: "article p{text-transform:uppercase;font-size:16px}",
+    // a short field label is the legitimate home of uppercase
+    negative: ".field-label{text-transform:uppercase;font-size:12px}",
+  },
+  "slop-t10-wide-tracking-body": {
+    ext: "css",
+    positive: "article p{letter-spacing:0.12em;font-size:16px}",
+    negative: "article p{letter-spacing:0.01em;font-size:16px}",
+  },
+  "slop-m1-bounce-easing": {
+    ext: "css",
+    // y1 = 1.56 overshoots the target and returns — the bounce signature
+    positive: ".card{transition:transform .3s cubic-bezier(.34,1.56,.64,1)}",
+    negative: ".card{transition:transform .3s cubic-bezier(.4,0,.2,1)}",
+  },
+  "slop-m3-img-hover-transform": {
+    ext: "css",
+    positive: ".tile:hover img{transform:scale(1.05)}",
+    negative: ".tile:hover .tile__title{color:#16202b}",
+  },
 };
 
 function findingsFor(ruleId: string, content: string, ext: string, ctx = NO_CTX) {