@event4u/agent-config 9.35.0 → 10.0.0

package/src/scripts/check_ci_local_parity.ts

@@ -38,6 +38,27 @@ const HOOK = path.join(REPO, 'src', 'scripts', 'install-hooks.sh');
 /** Roots of the local closure. `ci` is the local mirror; the hook is what a push runs. */
 const LOCAL_ROOTS = ['ci', 'consistency'] as const;
 
+/**
+ * Round 7 § Phase 3 — the third dimension, and why two were not enough.
+ *
+ * `task ci` INCLUDES `preflight` (`Taskfile.yml:87`), so the two roots above
+ * answer "does the local MIRROR match CI". The pass an agent is actually told to
+ * run before pushing is `task preflight`, a deliberate subset of `ci` — its own
+ * docstring excludes `check_enforcement_coverage` at a measured 30.7 s because
+ * "a pre-push gate that doubles the hook teaches people to skip it".
+ *
+ * That makes `CI ∩ ci \ preflight` invisible to this gate by construction, and it
+ * is exactly where round 7's measured "green locally, red remotely" cycles came
+ * from: the Thin-Root char cap, the ratchet living in the Node-Tests shard, and
+ * the derived-page freshness check.
+ *
+ * Reported, not gated. The subset is intentional, so failing on it would demand
+ * that `preflight` grow into `ci` — the opposite of what its author decided. What
+ * this dimension removes is the IMPLICATION that a green preflight means CI will
+ * be green.
+ */
+const PREFLIGHT_ROOTS = ['preflight'] as const;
+
 export interface Declared {
     id: string;
     class: string;
@@ -197,6 +218,19 @@ export interface ParityReport {
     undeclared_ci_only: string[];
     undeclared_local_only: string[];
     stale_declarations: string[];
+    /** Round 7 § Phase 3 — `task preflight`'s own closure. */
+    preflight_gates: string[];
+    /**
+     * `CI ∩ local \ (preflight ∪ pre-push hook)` — gates a push's remote run
+     * enforces, the local mirror covers, and NOTHING a push runs locally reaches.
+     * Report-only: the measured size of "green locally, red remotely", not a
+     * failure.
+     *
+     * The hook's own closure is in the subtrahend per R2 finding 4: subtracting
+     * preflight alone counted gates the pre-push hook already runs, which cannot
+     * fail after a push. That read 221; the honest figure is 209.
+     */
+    ci_not_in_preflight: string[];
 }
 
 export function analyse(repo = REPO, manifest?: Manifest): ParityReport {
@@ -231,12 +265,38 @@ export function analyse(repo = REPO, manifest?: Manifest): ParityReport {
         ...[...declaredLocal].filter((g) => localGates.has(g) && ciGates.has(g)),
     ].sort();
 
+    // Round 7 § 3.1 — the third dimension. Derived the same way as the other two,
+    // so it cannot drift from them by construction.
+    //
+    // R2 finding 4 (medium): the first version subtracted only the `preflight`
+    // closure from `localGates`, and `localGates` includes every gate reachable
+    // from `install-hooks.sh` — which the PRE-PUSH hook runs. A gate that runs
+    // before the push lands cannot produce a "green locally, red remotely" cycle,
+    // so counting it inflated the number and mislabelled it, in a step whose own
+    // text calls the number "the deliverable, not an adjective". The subtrahend is
+    // therefore everything a push already runs: preflight PLUS the hook's own
+    // closure.
+    const preflightGates = local_closure(PREFLIGHT_ROOTS, tasks);
+    const prePush = new Set(preflightGates);
+    if (fs.existsSync(HOOK)) {
+        const hook = fs.readFileSync(HOOK, 'utf-8');
+        for (const g of extract_gates(hook)) prePush.add(g);
+        for (const t of extract_tasks(hook)) {
+            for (const g of local_closure([t], tasks)) prePush.add(g);
+        }
+    }
+    const ci_not_in_preflight = [...ciGates]
+        .filter((g) => localGates.has(g) && !prePush.has(g))
+        .sort();
+
     return {
         ci_gates: [...ciGates].sort(),
         local_gates: [...localGates].sort(),
         undeclared_ci_only,
         undeclared_local_only,
         stale_declarations,
+        preflight_gates: [...preflightGates].sort(),
+        ci_not_in_preflight,
     };
 }
 
@@ -292,6 +352,20 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
         for (const g of r.stale_declarations) process.stdout.write(`  - ${g}\n`);
     }
 
+    // Round 7 § 3.2 — printed on EVERY path, pass or fail, because the number is
+    // the deliverable. A green parity verdict above says the local MIRROR matches
+    // CI; it says nothing about the pass a contributor is told to run, and reading
+    // the green line as if it did is the implication this block removes.
+    process.stdout.write(
+        `ℹ️   preflight: ${String(r.preflight_gates.length)} gate(s) of the ${String(r.local_gates.length)} local ones; ` +
+            `${String(r.ci_not_in_preflight.length)} CI-enforced gate(s) run NEITHER in \`task preflight\` NOR\n` +
+            '    anywhere else the pre-push hook reaches — i.e. the set that can only fail after\n' +
+            '    a push. `task ci` INCLUDES preflight, so the parity verdict above cannot see it.\n' +
+            '    Report-only: the subset is deliberate (see the preflight docstring). A green\n' +
+            '    preflight is therefore not a prediction that CI will be green.\n',
+    );
+    for (const g of r.ci_not_in_preflight) process.stdout.write(`      · ${g}\n`);
+
     if (!failed) {
         process.stdout.write(
             `✅  CI ↔ local parity: ${String(r.ci_gates.length)} CI gate(s), ${String(r.local_gates.length)} local, ` +

package/src/scripts/check_references.ts

@@ -57,7 +57,21 @@ function makeBrokenRef(
 
 const SCAN_DIRS = ['dist/agent-src', 'agents'];
 const SKIP_DIRS = [
-    'agents/roadmaps/archive', // archived roadmaps have historical refs
+    // Archived roadmaps have historical refs — a link to a file that existed when
+    // the plan was written is not drift, so the exclusion is right on the merits.
+    //
+    // ROUND 7, DOWNGRADE (2026-08-12): it also means this checker is the ONLY thing
+    // that would see a class of real rot, and cannot. Measured: **530 dead relative
+    // links across 147 of 466 archived roadmaps**. The cause is not history — it is
+    // that `archive_completed_roadmaps` moves a file one directory deeper and never
+    // re-depths its outgoing relative links, so a link that resolved before the move
+    // is broken BY the move. Two tools, one silence: the writer does not rewrite, and
+    // the only checker that would notice is scoped away from where it lands.
+    //
+    // Not repaired here: the fix is a bulk edit across 147 files plus a re-depth pass
+    // in the sweep, which is its own change. Recorded so the exclusion is read as a
+    // known gap with a number rather than as coverage.
+    'agents/roadmaps/archive',
     'agents/runtime/council/sessions', // per-user audit trail (gitignored), captured provider output
     'agents/runtime/council/responses', // paired council output (gitignored), captured provider output
     'agents/runtime/council/questions', // design Q&A trail — forward-refs to planned artifacts

package/src/scripts/condense.ts

@@ -359,8 +359,18 @@ const _ALL_TOOLS: ReadonlySet<string> = new Set([
 ]);
 void _ALL_TOOLS;
 
-function _active_tools(): ReadonlySet<string> | null {
-    const tools_file = path.join(MODULE_STATE.PROJECT_ROOT, 'agents', '.agent-tools.yml');
+/**
+ * Tool ids selected by `agents/.agent-tools.yml` under `root`, or `null` when
+ * the file is absent / malformed / carries no `tools:` list — `null` means
+ * "all tools active", never "none".
+ *
+ * Root-parameterised and exported so a consumer auditing a checkout other than
+ * `MODULE_STATE.PROJECT_ROOT` (a gate run with `--root`) reads the selection
+ * this generator actually honours, instead of re-implementing these four
+ * fallbacks and drifting from them.
+ */
+export function active_tools_at(root: string): ReadonlySet<string> | null {
+    const tools_file = path.join(root, 'agents', '.agent-tools.yml');
     if (!_exists(tools_file)) {
         return null;
     }
@@ -380,6 +390,10 @@ function _active_tools(): ReadonlySet<string> | null {
     return new Set(tools.filter((t): t is string => typeof t === 'string'));
 }
 
+function _active_tools(): ReadonlySet<string> | null {
+    return active_tools_at(MODULE_STATE.PROJECT_ROOT);
+}
+
 function _tool_active(tool_id: string): boolean {
     const active = _active_tools();
     return active === null ? true : active.has(tool_id);

package/src/scripts/conformance_scan.ts

@@ -41,6 +41,9 @@ import { isSyntheticPrompt } from "./_lib/prompt_shape.js";
 import { classifyAuthorization, type GitOp } from "./git_authorization_hook.js";
 import { BLOCK_OPS, commandOp } from "./hooks/block_unauthorized_git.js";
 import { isVacuousOutput, isCiPoll, pendingCount } from "./before_complete_hook.js";
+// Round 7 § 1.5 — the SAME predicate `turn-end-gate` refuses on, imported rather
+// 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";
 
 /**
@@ -57,7 +60,12 @@ import { isEvaluationPrompt, isSelfScoped, preloadedVerdict } from "./hooks/evid
 const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 export interface Violation {
-  check: "language-pin" | "git-authorization" | "vacuous-evidence" | "evidence-steering";
+  check:
+    | "language-pin"
+    | "git-authorization"
+    | "vacuous-evidence"
+    | "evidence-steering"
+    | "completion-claim";
   session: string;
   at: string;
   detail: string;
@@ -78,6 +86,17 @@ export interface SessionReport {
   user_turns: number;
   assistant_turns: number;
   violations: Violation[];
+  /**
+   * Round 7 § 6.2 — assistant turns that stood under a GERMAN pin, i.e. the only
+   * turns on which `language-pin` can fire at all. The rate was published over
+   * ALL assistant turns, which understates it by whatever fraction of a corpus is
+   * English-pinned: measured on round 7's own corpus, 1 655 of 2 354 (70 %), and
+   * the same 152 violations read 6.5 % on the old denominator and 9.2 % on this
+   * one — enough to move the band verdict from OUTSIDE to INSIDE.
+   */
+  de_pin_turns: number;
+  /** First entry timestamp, so a reader can era-split without a second pass. */
+  first_at: string;
 }
 
 /**
@@ -134,7 +153,7 @@ export const OBSERVED_BAND = { low: 9.1, high: 39.2 } as const;
  */
 export const BAND_MIN_TURNS = 1978;
 
-export type BandVerdict = "inside" | "outside" | "corpus-too-small";
+export type BandVerdict = "inside" | "outside" | "corpus-too-small" | "era-spanning";
 
 /** Round-6 Phase 4.5 — the forward-capture record for one scan run. */
 export interface RateRecord {
@@ -144,7 +163,29 @@ export interface RateRecord {
   assistant_turns: number;
   language_pin: number;
   rate_pct: number;
-  /** `outside` is the falsifier firing; `corpus-too-small` is not a reading. */
+  /**
+   * Round 7 § 6.2 / 6.1 — OPTIONAL, and not for convenience.
+   *
+   * `--record` appends one line per run to a series whose whole purpose is
+   * comparability over time, and every line written before round 7 carries none
+   * of these four. Declaring them required would make the type say something
+   * false about the records on disk, and the renderer already reads them
+   * defensively for exactly that reason. `analyse()` always populates them, so a
+   * fresh run is never partial — the optionality describes the archive, not the
+   * producer.
+   */
+  de_pin_turns?: number;
+  /** The same numerator over `de_pin_turns`. Reported beside `rate_pct`, never instead. */
+  rate_pct_de_pin?: number;
+  /** The corpus straddles a carrier landing, so no band verdict. */
+  era_spanning?: boolean;
+  /** Which carrier, when `era_spanning` — empty otherwise. */
+  era_reason?: string;
+  /**
+   * `outside` is the falsifier firing; `corpus-too-small` and `era-spanning` are
+   * not readings — the first is about corpus size, the second about the corpus
+   * containing two different systems.
+   */
   band: BandVerdict;
   /**
    * `null` when the scanned store is NOT this repo's own — `measureDelivered` is
@@ -157,7 +198,49 @@ export interface RateRecord {
   delivered_global_tokens: number | null;
 }
 
-export function bandVerdict(rate_pct: number, assistant_turns: number): BandVerdict {
+/**
+ * Round 7 § 6.1 — dates on which a carrier for a mechanised check LANDED.
+ *
+ * A rate pooled across one of these is not a reading about behaviour; it is a
+ * weighted average of two different systems. The band's falsifier is "a fourth
+ * PROJECT outside the band", and on round 7's first run it fired on the project
+ * that helped DEFINE the band — because the corpus straddled the language-pin
+ * carrier. 23.1 % before it, 0.0 % after, 6.5 % pooled, and the pooled figure was
+ * announced as the falsifier.
+ *
+ * Declared as data with provenance rather than inferred: nothing in a transcript
+ * records which carriers were bound while it was written.
+ */
+export const CARRIER_CHANGES: readonly { at: string; what: string }[] = [
+  { at: "2026-08-07T00:00:00Z", what: "language-pin bound on user_prompt_submit (round 5)" },
+];
+
+/** True when the corpus spans a carrier change, i.e. two systems in one average. */
+export function spansCarrierChange(firstAts: readonly string[]): { spans: boolean; what: string } {
+  const stamps = firstAts.filter((s) => s !== "").sort();
+  if (stamps.length === 0) {
+    return { spans: false, what: "" };
+  }
+  const lo = stamps[0] as string;
+  const hi = stamps[stamps.length - 1] as string;
+  for (const c of CARRIER_CHANGES) {
+    if (lo < c.at && hi >= c.at) {
+      return { spans: true, what: c.what };
+    }
+  }
+  return { spans: false, what: "" };
+}
+
+export function bandVerdict(
+  rate_pct: number,
+  assistant_turns: number,
+  opts: { spansCarrier?: boolean } = {},
+): BandVerdict {
+  // The era guard is checked FIRST and for the same reason the turn floor is: a
+  // verdict about corpus shape must not be reported as a verdict about behaviour.
+  if (opts.spansCarrier === true) {
+    return "era-spanning";
+  }
   if (assistant_turns < BAND_MIN_TURNS) {
     return "corpus-too-small";
   }
@@ -181,6 +264,7 @@ export const CHECK_IDS: readonly CheckId[] = [
   "git-authorization",
   "vacuous-evidence",
   "evidence-steering",
+  "completion-claim",
 ];
 
 /**
@@ -207,6 +291,12 @@ export const CHECK_MEANINGS: Record<CheckId, string> = {
   "evidence-steering":
     "A self-commissioned evaluation whose prompt pre-loaded its own verdict, " +
     "or a second self-scoped evaluation of the same subject within one turn.",
+  "completion-claim":
+    "An assistant turn claiming the work is complete while the last CI read in " +
+    "that session was NOT settled. Round 7 measured 14 instances by reading, " +
+    "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.",
 };
 
 /**
@@ -317,7 +407,11 @@ export function isInjectedBody(text: string): boolean {
  * `API Error: 529 Overloaded` retry banners. Counting the harness as the model
  * inflates the very number this scan exists to report honestly.
  */
-const HARNESS_TEXT =
+// Exported since round 7 § 6.3: `probe_session_canary` needs the SAME predicate,
+// and its first version had its own copy that omitted `You've hit your` — which
+// turned a spend-limit banner into a missed greeting and reported 24/28 for a
+// corpus that is 25/28.
+export const HARNESS_TEXT =
   /^(API Error:|Request (timed out|was aborted)|\[Request interrupted|Error: |Credit balance is too low|You've hit your|Prompt is too long)/i;
 
 /** Rough English-opener test for the language check (first prose line only). */
@@ -330,6 +424,8 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
     user_turns: 0,
     assistant_turns: 0,
     violations: [],
+    de_pin_turns: 0,
+    first_at: "",
   };
 
   let pinned: "de" | "en" | null = null;
@@ -343,6 +439,10 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
   // that split reproducible against a future corpus instead of re-argued.
   let turnsSincePrompt = 0;
   let compactionSincePrompt = false;
+  // Round 7 § 1.5 — session-scoped, deliberately NOT reset per prompt: the
+  // measured failure is a completion claim in a LATER turn than the poll.
+  let ciSeen = false;
+  let ciSettled = false;
 
   for (const line of lines) {
     if (!line.trim()) {
@@ -354,6 +454,12 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
     } catch {
       continue;
     }
+    // Round 7 § 6.1 — captured for the era guard. The FIRST timestamp in the
+    // file, not the file mtime: mtime moves when a session is resumed, which
+    // would put a July session in the August era.
+    if (report.first_at === "" && typeof entry["timestamp"] === "string") {
+      report.first_at = entry["timestamp"];
+    }
 
     // Tool results arrive as `user` entries carrying `toolUseResult`.
     if (entry["type"] === "user" && entry["toolUseResult"] !== undefined && pendingPoll !== null) {
@@ -370,6 +476,14 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
           detail: `CI poll read as settled without an in-flight observation: ${out.slice(0, 90)}`,
         });
       }
+      // Round 7 § 1.5 — the session-scoped CI-settle state the completion-claim
+      // check reads. R2 finding 3: this copied `pending === 0` AND the wrong
+      // comment claiming it matched the producer's discrimination. It did not —
+      // a stale all-pass table read as a settle and silenced the check. The
+      // in-flight witness is required here too, so the measurement and the gate
+      // agree on what a settle is.
+      ciSeen = true;
+      ciSettled = pending === 0 && sawPending && !isVacuousOutput(out);
       pendingPoll = null;
       continue;
     }
@@ -424,6 +538,26 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
     if (prose !== null) {
       report.assistant_turns += 1;
       turnsSincePrompt += 1;
+      // 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.
+      if (pinned === "de") {
+        report.de_pin_turns += 1;
+      }
+      // Round 7 § 1.5 — placed BEFORE the language block on purpose: that block
+      // `continue`s on a harness banner, and a check placed after it would be
+      // skipped for every such turn without saying so.
+      if (!HARNESS_TEXT.test((prose.split("\n").find((l) => l.trim()) ?? "").trim())) {
+        const cc = detectCompletionClaim(prose, { seen: ciSeen, settled: ciSettled });
+        if (cc !== null) {
+          report.violations.push({
+            check: "completion-claim",
+            session: sessionId,
+            at,
+            detail: `completion claimed over an unsettled CI read: "${cc.evidence.slice(0, 110)}"`,
+          });
+        }
+      }
       if (pinned === "de") {
         const first = prose.split("\n").find((l) => l.trim()) ?? "";
         if (HARNESS_TEXT.test(first.trim())) {
@@ -585,6 +719,7 @@ export function scanStore(store: string, limit: number): ScanReport {
     "git-authorization": 0,
     "vacuous-evidence": 0,
     "evidence-steering": 0,
+    "completion-claim": 0,
   };
   for (const s of per_session) {
     for (const v of s.violations) {
@@ -600,6 +735,14 @@ export function scanStore(store: string, limit: number): ScanReport {
   // band" — a rounding artefact announcing the declared falsifier.
   const rate_pct =
     assistant_turns === 0 ? 0 : Number(((100 * language_pin) / assistant_turns).toFixed(1));
+  // Round 7 § 6.2 — the second denominator, reported beside the first rather than
+  // instead of it: replacing the figure silently would break comparability with
+  // every recorded run, and the band's own three reference values were computed
+  // on the all-turns denominator.
+  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));
+  const era = spansCarrierChange(per_session.map((s) => s.first_at));
   const delivered = measureDelivered(
     path.join(REPO_ROOT, ".claude", "rules"),
     path.join(process.env["HOME"] ?? os.homedir(), ".claude", "rules"),
@@ -619,7 +762,11 @@ export function scanStore(store: string, limit: number): ScanReport {
       assistant_turns,
       language_pin,
       rate_pct,
-      band: bandVerdict(rate_pct, assistant_turns),
+      de_pin_turns,
+      rate_pct_de_pin,
+      era_spanning: era.spans,
+      era_reason: era.what,
+      band: bandVerdict(rate_pct, assistant_turns, { spansCarrier: era.spans }),
       // Only attach the carrier figures when the rate and the carriers describe
       // the same project.
       delivered_project_tokens: ownStore ? delivered.project.tokens : null,
@@ -680,7 +827,36 @@ export function render(report: ScanReport): string {
     `  language-pin rate  ${report.rate.rate_pct.toFixed(1)}%  ` +
       `(${report.rate.language_pin} of ${report.rate.assistant_turns} assistant turns)`,
   );
-  if (report.rate.band === "corpus-too-small") {
+  // Round 7 § 6.2 — both denominators, always. The band's three reference values
+  // were computed on the all-turns one, so that stays the headline; the second is
+  // the only one the check can actually fire on, and on round 7's own corpus the
+  // two differ by enough to move the verdict (6.5 % vs 9.2 %, band low 9.1 %).
+  // Optional-read, not `report.rate.x.toFixed(...)`: a `rate` block RECORDED
+  // before round 7 carries neither field, and `--record` exists to be read back
+  // over time. A renderer that throws on last month's line makes the series
+  // unreadable to prove a point about denominators.
+  const dePinTurns = report.rate.de_pin_turns;
+  const dePinRate = report.rate.rate_pct_de_pin;
+  if (typeof dePinTurns === 'number' && typeof dePinRate === 'number') {
+    lines.push(
+      `                     ${dePinRate.toFixed(1)}%  ` +
+        `(${report.rate.language_pin} of ${dePinTurns} turns under a GERMAN pin — the only` +
+        ' turns this check can fire on)',
+    );
+    lines.push(
+      '    The band (M5, n=3) was computed on the ALL-turns denominator, so the first figure',
+    );
+    lines.push('    is the comparable one and the second is the honest one. Both are printed.');
+  }
+  if (report.rate.band === "era-spanning") {
+    lines.push(
+      `    Not compared: the corpus SPANS a carrier landing — ${report.rate.era_reason || 'see CARRIER_CHANGES'}.`,
+    );
+    lines.push('    A rate pooled across it is a weighted average of two different systems, not');
+    lines.push('    a reading about behaviour. Round 7 measured 23.1% before and 0.0% after that');
+    lines.push('    exact carrier; the pooled 6.5% was announced as the falsifier firing.');
+    lines.push('    Split the window at the carrier date and read each era on its own.');
+  } else if (report.rate.band === "corpus-too-small") {
     lines.push(
       `    Not compared: ${report.rate.assistant_turns} turns is below the ${BAND_MIN_TURNS} of the`,
     );
@@ -702,8 +878,23 @@ export function render(report: ScanReport): string {
     lines.push("    as new. Store novelty is not project novelty.");
   }
   lines.push("");
-  lines.push("  Scanned checks are exactly the mechanised ones. Ask-shape, session-canary,");
-  lines.push("  promissory closings and checkbox batching are left as prose and NOT measured.");
+  // Round 7 § 6.4 — this footer used to lump four classes together as "NOT
+  // measured", and two of the four were wrong. Stated per class instead, because
+  // "not measured here" and "not measured anywhere" are different facts and only
+  // one of them is a gap.
+  lines.push("  Scanned checks are exactly the mechanised ones. What is NOT in the counts above:");
+  lines.push("    ask-shape (trailing free-text offer)  — measured NOWHERE. ~11 findings in round 7's");
+  lines.push("      reading half; the discriminator needs judgement, so it stays advisory on purpose.");
+  lines.push("    session-canary (opening greeting)     — not here, but PROBEABLE:");
+  lines.push("      `./scripts-run src/scripts/probe_session_canary`. Round 7: 25/28 sessions,");
+  lines.push("      24/25 post-carrier. The per-TASK instance is undecidable — no task boundary");
+  lines.push("      is recorded in a transcript.");
+  lines.push("    promissory closings                   — not here, but ALREADY GATED: `turn-end-gate`");
+  lines.push("      ships a blocking `detectPromissory`. Round 7 probe: 1 of 120 hand-back turns");
+  lines.push("      (the 163 this line first printed was the retracted denominator — it counted");
+  lines.push("      synthetic user turns as hand-back closers).");
+  lines.push("      `./scripts-run src/scripts/probe_promissory_closing`.");
+  lines.push("    checkbox batching                     — measured NOWHERE. ~5 low-severity findings.");
   return lines.join("\n");
 }
 

package/src/scripts/council_cli.ts

@@ -749,11 +749,18 @@ function _postRunQuorum(
     for (let i = 0; i < members.length; i++) {
         const m = members[i] as ExternalAIClient;
         const r = responses[i];
-        if (r !== undefined && !r.error) {
+        // Round 7 § 5.2 — attendance is a NON-EMPTY answer, not the absence of an
+        // error. `!r.error` alone counted a member that returned zero bytes, and
+        // that is not hypothetical: a 290 s curl timeout returned an empty body
+        // with no error set in two sessions (`9fc9ba3e`, `4ac2f7ac`) and the
+        // banner printed `2/2 present` — a single-voice verdict presented as
+        // convergence, on a paid run. An empty answer contributes nothing to a
+        // quorum by definition, whatever the transport thought of it.
+        if (r !== undefined && !r.error && r.text.trim() !== '') {
             present += 1;
             continue;
         }
-        const raw = r?.error ?? 'no response';
+        const raw = r?.error ?? (r !== undefined && r.text.trim() === '' ? 'empty response body' : 'no response');
         const failure = classifyCliFailure(raw);
         absent.push({
             member: m.name,
@@ -772,7 +779,14 @@ function _postRunQuorum(
  */
 function _format_quorum_line(q: QuorumResult): string {
     const verdict = q.status === 'concluded' ? 'concluded' : 'INCONCLUSIVE — release gate holds';
-    return `council:quorum · ${q.present}/${q.total} present, needed ${q.threshold} — ${verdict}.`;
+    // 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
+    // a solo answer concludes, and nothing in the line distinguishes "both
+    // members agreed" from "one member answered". The counts were always there;
+    // 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}`;
 }
 
 function build_members(settings: Dict, opts: BuildMembersOptions = {}): ExternalAIClient[] {
@@ -2328,6 +2342,31 @@ function _emit_shadow_slo_banner(): void {
  * leaves nothing to infer. Exit is always 0 — this reports a state, it does not
  * gate — and the verdict line is machine-greppable in both directions.
  */
+/**
+ * Resolve the concrete transport a member would use on THIS machine right now.
+ *
+ * `cmd_status` exists to answer "is the council reachable, and will it bill me".
+ * Since the transport-mode setting was removed, the second half is not a value
+ * anyone can look up in the config — it is a per-machine resolution. Printing a
+ * configured mode would be the same class of stale answer the removed setting
+ * produced. `mode` is pinned to `auto` because the loader no longer emits
+ * anything else.
+ */
+function _resolvedTransportFor(
+    name: string,
+    member: { readonly binary: string | null; readonly api_key_ref: string | null },
+    report?: EnvironmentReport,
+): ReturnType<typeof resolveMemberTransport> {
+    return resolveMemberTransport({
+        provider: name,
+        report: report ?? detectEnvironment(),
+        invocationMode: null,
+        memberSettings: null,
+        globalMode: 'auto',
+        binaryOverride: member.binary,
+    });
+}
+
 export function cmd_status(args: Args, opts: { env?: Record<string, string | undefined> } = {}): number {
     const env = opts.env ?? process.env;
     const override = env[COUNCIL_CONFIG_ENV];
@@ -2363,6 +2402,21 @@ export function cmd_status(args: Args, opts: { env?: Record<string, string | und
                 members_total: cfg === null ? null : cfg.members.size,
                 members_enabled: cfg === null ? null : enabledMembers.length,
                 member_names: enabledMembers.map(([n]) => n),
+                transports: Object.fromEntries(
+                    enabledMembers.map(([n, m]) => {
+                        const t = _resolvedTransportFor(n, m);
+                        return [
+                            n,
+                            {
+                                available: t.available,
+                                transport: t.available ? t.transport : null,
+                                billing: t.available ? t.billing : null,
+                                reason: t.reason,
+                            },
+                        ];
+                    }),
+                ),
+                ignored_transport_keys: cfg?.ignored_transport_keys ?? [],
                 parse_error,
                 project_tree_consulted: false,
             })}\n`,
@@ -2383,6 +2437,25 @@ export function cmd_status(args: Args, opts: { env?: Record<string, string | und
         if (enabledMembers.length > 0) {
             _stdout(`                   ${enabledMembers.map(([n]) => n).join(', ')}\n`);
         }
+        // Transport is resolved per machine, so the only honest way to answer
+        // "will this cost money" is to resolve it here rather than print a
+        // configured value. The billing class comes from the detected auth
+        // source, never from the transport name — a community CLI wrapper
+        // shells out to the same paid API and stays metered.
+        for (const [name, member] of enabledMembers) {
+            const t = _resolvedTransportFor(name, member);
+            const billing = t.available ? ` · ${t.billing}` : '';
+            const detail = t.available ? t.transport : `unavailable — ${t.reason ?? 'no usable transport'}`;
+            _stdout(`  transport        ${name}: ${detail}${billing}\n`);
+        }
+        if (cfg.ignored_transport_keys.length > 0) {
+            _stdout('\n');
+            _stdout('  Ignored transport keys — transport is resolved, not configured:\n');
+            for (const key of cfg.ignored_transport_keys) {
+                _stdout(`    ${key}\n`);
+            }
+            _stdout('  Safe to delete from the config file; they change nothing.\n');
+        }
     }
     _stdout('\n');
     _stdout('  The project tree is NEVER consulted (ADR-104). No project file —\n');
@@ -2593,6 +2666,25 @@ function cmd_run(
         return 0;
     }
 
+    // Round 7 § 5.1 — VALIDATE THE OUTPUT PATH BEFORE THE FIRST BILLABLE CALL.
+    //
+    // The only validation used to sit immediately before the WRITE, i.e. after
+    // every member had been paid, so a wrong directory discarded a completed run.
+    // Measured across round 7's corpus: ~$1.30 in three sessions (`291f827b`
+    // ~$0.42, `9502795e` $0.44, plus a discarded run each in `d6154522` and
+    // `3d50d0df`). The trap sat in the operator's notes for weeks and was still
+    // paid twice, because the defect is the ORDERING, not the caller.
+    //
+    // Placed HERE, after the `--confirm` gate, and not at function entry: the
+    // estimate-only path neither writes nor bills, and the first attempt at this
+    // fix validated at entry and broke it — caught by
+    // `council_cli.test.ts`'s no-confirm case. Nothing above this line spends.
+    //
+    // The validator is pure, so the pre-write call stays: it returns the string
+    // the write uses, and removing it to avoid "duplicate work" would put the
+    // guarantee back in a single place that runs late.
+    _validate_council_output_path(args.output as string, { kind: 'responses', subcommand: 'run' });
+
     const cost_cfg = (ai_cfg['cost_budget'] as Dict) || {};
     const budget = new CostBudget({
         max_input_tokens: _pyInt(cost_cfg['max_input_tokens'] ?? 50_000, 50_000),