@event4u/agent-config 9.27.0 → 9.29.0

package/src/scripts/condense.ts

@@ -1174,11 +1174,27 @@ export function generate_rule_symlinks(): number {
         const skip = new Set(rules.filter((r) => !emit_here.has(r)));
         skipped_per_tool[tool_dir] = skip;
         _mkdirp(target_dir);
-        // Clean stale symlinks — a rule that became de-duplicable this run is
+        // Clean stale entries — a rule that became de-duplicable this run is
         // stale at project scope too, so it has to go with the rest.
+        //
+        // Symlink-only was correct while every tool dir was a symlink tree. Two
+        // paths now write REAL files (`thin` mode, and the Claude emitter
+        // below), and a stale real file is invisible to an `_isSymlink` test —
+        // so a renamed or newly de-duplicable rule would leave its body behind,
+        // loaded unconditionally, forever.
+        //
+        // Ownership test for a real file: its basename is an agent-config rule
+        // in the projection source. A consumer's own hand-written rule is only
+        // touched if it collides with one of ours by name, in which case it was
+        // already being overwritten.
         for (const item of _iterdirSorted(target_dir)) {
             const name = path.basename(item);
-            if (_isSymlink(item) && (!rules.includes(name) || skip.has(name)) && name !== 'README.md') {
+            if (name === 'README.md') {
+                continue;
+            }
+            const is_ours =
+                _isSymlink(item) || _isFile(path.join(MODULE_STATE.RULES_SOURCE, name));
+            if (is_ours && (!rules.includes(name) || skip.has(name))) {
                 fs.unlinkSync(item);
             }
         }
@@ -1192,6 +1208,11 @@ export function generate_rule_symlinks(): number {
             }
             if (thin_files !== null) {
                 _writeText(link, thin_files[rule] as string);
+            } else if (tool_dir === '.claude/rules') {
+                // Host-native activation (P3.1): emit the rule with the host's
+                // own `paths:` key instead of symlinking agent-config
+                // frontmatter this host does not read.
+                _emit_claude_rule(path.join(MODULE_STATE.RULES_SOURCE, rule), link);
             } else {
                 fs.symlinkSync(path.join(rel_prefix, rule), link);
             }
@@ -1355,6 +1376,145 @@ export function _emit_windsurf_rule(source: string, target: string): void {
     _writeText(target, lines.join('\n'));
 }
 
+/**
+ * A brace group the host expands, versus an agent-config placeholder that only
+ * LOOKS like one.
+ *
+ * `path_prefix: "{module_root}/"` in `roadmap-ci-steps-policy` is resolved by
+ * this suite from `modules.root_paths`. Emitted verbatim into a host `paths:`
+ * list it is a brace group with no comma, which the host expands to the literal
+ * string `{module_root}` — a pattern that matches no file. The rule would then
+ * reach the model **never** instead of on-demand, and nothing would say so: the
+ * probed contract records this exact degradation as silent
+ * (`claude-code-rules-dir-contract.md` § constraints).
+ *
+ * Dropping the pattern is fail-safe in the one direction that matters. A rule
+ * left with no pattern at all carries no `paths:` key and loads
+ * unconditionally — the status quo, not a regression. A rule carrying a
+ * no-op pattern is invisible.
+ *
+ * The discriminator is the comma, not a placeholder allowlist: `{ts,tsx}` is a
+ * real alternation, `{module_root}` cannot be one.
+ */
+export function _is_unresolved_placeholder(pattern: string): boolean {
+    for (const m of pattern.matchAll(/\{([^}]*)\}/g)) {
+        if (!(m[1] as string).includes(',')) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * `[` opens a bracket expression for the host. An unparseable one makes that
+ * pattern match nothing while the rule's other patterns keep working — so a
+ * literal `[` in a trigger is escaped rather than trusted.
+ */
+export function _escape_claude_bracket(pattern: string): string {
+    return pattern.replace(/\[/g, '\\[');
+}
+
+/**
+ * Expanded-pattern cost of one glob: the product of its brace alternations.
+ * The host budgets a rule's whole `paths:` list at 1,000 expanded patterns and
+ * 4 MiB, and a list over budget is used UNEXPANDED — braces then match
+ * literally, i.e. nothing. Counting keeps the emitter under the cliff instead
+ * of discovering it as a silent no-op.
+ */
+export function _expanded_pattern_count(pattern: string): number {
+    let n = 1;
+    for (const m of pattern.matchAll(/\{([^}]*)\}/g)) {
+        n *= (m[1] as string).split(',').length;
+    }
+    return n;
+}
+
+/** Host-documented budget for one rule's whole `paths:` list. */
+export const CLAUDE_PATHS_PATTERN_BUDGET = 1000;
+
+export interface ClaudePathsPlan {
+    /** Patterns to emit under `paths:`, in declaration order. */
+    globs: string[];
+    /** Patterns deliberately not emitted, with the reason a reader can act on. */
+    dropped: { pattern: string; reason: 'unresolved-placeholder' | 'over-budget' }[];
+}
+
+/**
+ * Derive the host's `paths:` list for one rule, with every drop recorded.
+ *
+ * Kernel / always-apply rules get an EMPTY list on purpose: absent `paths:` is
+ * how this host says "load unconditionally", which is exactly what an Iron-Law
+ * rule needs. Scoping one would be a correctness regression dressed as a byte
+ * saving — and the same contract notes path-scoped rules are not re-injected
+ * after `/compact`, so an obligation that must survive compaction cannot be
+ * path-scoped at all.
+ */
+export function _claude_paths_plan(meta: Record<string, unknown>): ClaudePathsPlan {
+    const always_apply = Boolean(meta['alwaysApply'] || meta['type'] === 'always');
+    if (always_apply) {
+        return { globs: [], dropped: [] };
+    }
+    const globs: string[] = [];
+    const dropped: ClaudePathsPlan['dropped'] = [];
+    let spent = 0;
+    for (const raw of derive_trigger_globs(meta)) {
+        if (_is_unresolved_placeholder(raw)) {
+            dropped.push({ pattern: raw, reason: 'unresolved-placeholder' });
+            continue;
+        }
+        const cost = _expanded_pattern_count(raw);
+        if (spent + cost > CLAUDE_PATHS_PATTERN_BUDGET) {
+            dropped.push({ pattern: raw, reason: 'over-budget' });
+            continue;
+        }
+        spent += cost;
+        globs.push(_escape_claude_bracket(raw));
+    }
+    return { globs, dropped };
+}
+
+/**
+ * Emit a Claude Code rule carrying the host's OWN activation key.
+ *
+ * Sibling of {@link _emit_cursor_mdc} and {@link _emit_windsurf_rule}, and the
+ * third member of a set that had two. `.claude/rules` was a symlink projection
+ * of `dist/agent-src/rules`, which carried agent-config's own frontmatter
+ * vocabulary (`type`, `tier`, `triggers`, `alwaysApply`, …) into a host that
+ * reads **none** of it — so every rule loaded unconditionally and the corpus
+ * arrived in full every session.
+ *
+ * Emitted frontmatter is therefore `paths:` and nothing else: the one key the
+ * probed contract records as read by this host. A rule with no path-shaped
+ * trigger gets no frontmatter at all rather than a block the host ignores —
+ * keys that do nothing are bytes in every session's standing context.
+ *
+ * The body is copied byte-for-byte from the projection source (ADR-201's
+ * copy-plus-rewrite discipline); only the frontmatter is host-shaped.
+ */
+export function _emit_claude_rule(source: string, target: string): void {
+    const [meta, body] = _parse_frontmatter(_readText(source));
+    const plan = _claude_paths_plan(meta);
+    for (const d of plan.dropped) {
+        _print(
+            `  ⚠️  ${path.basename(target)}: dropped \`paths:\` pattern ${JSON.stringify(d.pattern)} (${d.reason}) — ` +
+                (plan.globs.length > 0
+                    ? 'the rule keeps its other patterns'
+                    : 'the rule now loads unconditionally'),
+        );
+    }
+    const lines: string[] = [];
+    if (plan.globs.length > 0) {
+        lines.push('---', 'paths:');
+        for (const g of plan.globs) {
+            lines.push(`  - ${_yaml_scalar(g)}`);
+        }
+        lines.push('---', '');
+    }
+    lines.push(_pyRstrip(body) + '\n');
+    _mkdirp(path.dirname(target));
+    _writeText(target, lines.join('\n'));
+}
+
 /** Python str.rstrip() with no args. */
 function _pyRstrip(s: string): string {
     return s.replace(/\s+$/u, '');

package/src/scripts/config/profiles.ts

@@ -130,7 +130,17 @@ function _load_yaml(p: string): Dict {
     return _isPlainDict(data) ? (data as Dict) : {};
 }
 
-function _profile_file(project_root: string, profile_id: string): string {
+/**
+ * The file `resolve_profile` will read for `profile_id`, or the legacy path
+ * when no candidate exists.
+ *
+ * Exported because a probe that reports "which profile is active" must name
+ * the file the resolver actually used. Re-deriving that path in the caller is
+ * how the two answers drift apart, which is the defect class
+ * `road-to-capability-answerability` exists to close — so there is exactly one
+ * implementation and both the resolver and `packs:active` call it.
+ */
+export function profile_file(project_root: string, profile_id: string): string {
     const legacy = path.join(project_root, PROFILES_DIRNAME, `${profile_id}.yml`);
     if (_exists(legacy)) {
         return legacy;
@@ -230,11 +240,11 @@ export function resolve_profile(params: {
         }
         return _build_resolved(
             DEFAULT_PROFILE_ID,
-            _load_yaml(_profile_file(params.project_root, DEFAULT_PROFILE_ID)),
+            _load_yaml(profile_file(params.project_root, DEFAULT_PROFILE_ID)),
             { source: SOURCE_DEFAULT },
         );
     }
-    const yaml_path = _profile_file(params.project_root, profile_id);
+    const yaml_path = profile_file(params.project_root, profile_id);
     if (!_exists(yaml_path)) {
         throw new ProfileError(
             `profile.id=${_repr(profile_id)} (${source}) but ${yaml_path} not found`,

package/src/scripts/conformance_scan.ts

@@ -27,16 +27,35 @@
  * store. It answers "did the shipped gates have anything to bite on?" —
  * which is also the only honest way to find out whether they help.
  */
+import { createHash } from "node:crypto";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
+import { censusRuleDir } from "./_lib/carrier_divergence.js";
+import { entryText, isSidechain } from "./_lib/transcript_entry.js";
+
 import { classify } from "./language_mirror_hook.js";
+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";
 import { isEvaluationPrompt, isSelfScoped, preloadedVerdict } from "./hooks/evidence_independence.js";
 
+/**
+ * This module's own repo root, NOT `process.cwd()`.
+ *
+ * Both the project carrier and the rate series are anchored here. Resolving them
+ * against the cwd made a run from any subdirectory record
+ * `delivered_project_tokens: 0` and append the series to a fresh
+ * `agents/runtime/state/` tree at that location — outside the ignore rule whose
+ * coverage the docstring claims, and silently splitting a series whose whole
+ * point is comparability. Under the bundled CLI `import.meta.url` still resolves
+ * inside the package, which is the tree whose rules are being measured.
+ */
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
 export interface Violation {
   check: "language-pin" | "git-authorization" | "vacuous-evidence" | "evidence-steering";
   session: string;
@@ -61,12 +80,98 @@ export interface SessionReport {
   violations: Violation[];
 }
 
+/**
+ * Rule text reaching context, per carrier — round-6 Phase 4.3, and the
+ * instrument the `essential` default-flip decision has been waiting on. Token
+ * basis: chars/4, the same estimate `preamble_byte_census` and
+ * `measure_scope_dedup` use, so the three numbers are comparable.
+ *
+ * MEASURED AT SCAN TIME, NOT PER SESSION — and the step asked for per-session.
+ * The delivered payload is a property of the CARRIERS ON DISK, and the
+ * transcript records none of it (verified in `preamble_byte_census`: a
+ * transcript carries `message.usage` counts and response content, no system or
+ * tools field). The carriers also change under the sessions — this round alone
+ * added three rules and refreshed the global install. So attaching today's
+ * figure to a session from three weeks ago would be a fabrication dressed as a
+ * per-session measurement, and the honest shape is one reading per scan run
+ * plus the forward series 4.5 records. That correction is why 4.3 and 4.5 are
+ * one mechanism rather than two.
+ */
+export interface DeliveredPayload {
+  /**
+   * `present` distinguishes a measured zero from a carrier that is not there.
+   * Without it a run from the wrong directory records `tokens: 0`, halves
+   * `union_tokens`, and persists a record indistinguishable from a real reading
+   * into a series whose entire purpose is comparability over time. The sibling
+   * `report_carrier_divergence` carries the same flag and refuses to substitute a
+   * different tree; this is the same refusal.
+   */
+  project: { dir: string; present: boolean; files: number; tokens: number };
+  global: { dir: string; present: boolean; files: number; tokens: number };
+  /** What a machine carrying BOTH carriers pays — the figure M5 compared across projects. */
+  union_tokens: number;
+}
+
+/**
+ * The band M5 observed across the only three stores with a corpus worth
+ * measuring (`private/capisco` 39.2 %, this package 25.4 %,
+ * `private/agent-switch` 9.1 %). Both council members independently named the
+ * same falsifier for cancelling the volume test: **a fourth project falling
+ * outside this band**. It is a constant here, with its source, because a
+ * falsifier nobody can evaluate is not one.
+ */
+export const OBSERVED_BAND = { low: 9.1, high: 39.2 } as const;
+
+/**
+ * The smallest corpus the band was derived from — `private/capisco`, 1 978
+ * assistant turns. NOT a chosen threshold: a rate computed over materially fewer
+ * turns is not comparable to the three that defined the band, and declaring it
+ * out-of-band would fire the falsifier on corpus size rather than on behaviour.
+ *
+ * The first run of this instrument proved the point: the worktree's own store
+ * read 4.1 % over 606 turns and would have announced the falsifier on its second
+ * day of existence.
+ */
+export const BAND_MIN_TURNS = 1978;
+
+export type BandVerdict = "inside" | "outside" | "corpus-too-small";
+
+/** Round-6 Phase 4.5 — the forward-capture record for one scan run. */
+export interface RateRecord {
+  /** Not the store path: a stable digest of it. See `storeKey`. */
+  store_key: string;
+  sessions: number;
+  assistant_turns: number;
+  language_pin: number;
+  rate_pct: number;
+  /** `outside` is the falsifier firing; `corpus-too-small` is not a reading. */
+  band: BandVerdict;
+  /**
+   * `null` when the scanned store is NOT this repo's own — `measureDelivered` is
+   * always anchored on this checkout, so pairing another project's rate with
+   * these tokens would persist a figure that belongs to neither. Cross-project
+   * `--record` is exactly the use 4.5 exists for, so the mismatch would have been
+   * the common case rather than an edge one.
+   */
+  delivered_project_tokens: number | null;
+  delivered_global_tokens: number | null;
+}
+
+export function bandVerdict(rate_pct: number, assistant_turns: number): BandVerdict {
+  if (assistant_turns < BAND_MIN_TURNS) {
+    return "corpus-too-small";
+  }
+  return rate_pct >= OBSERVED_BAND.low && rate_pct <= OBSERVED_BAND.high ? "inside" : "outside";
+}
+
 export interface ScanReport {
   scanned_at: string;
   store: string;
   sessions: number;
   totals: Record<string, number>;
   per_session: SessionReport[];
+  delivered: DeliveredPayload;
+  rate: RateRecord;
 }
 
 type Entry = Record<string, unknown>;
@@ -77,20 +182,14 @@ function _isObject(v: unknown): v is Record<string, unknown> {
 
 /** Text of a user-role entry, or null when it is not a real chat message. */
 export function userText(entry: Entry): string | null {
-  if (entry["type"] !== "user" || entry["isSidechain"] === true) {
+  if (entry["type"] !== "user" || isSidechain(entry)) {
     return null;
   }
-  const msg = entry["message"];
-  const content = _isObject(msg) ? msg["content"] : undefined;
-  let text = "";
-  if (typeof content === "string") {
-    text = content;
-  } else if (Array.isArray(content)) {
-    text = content
-      .filter((b) => _isObject(b) && b["type"] === "text")
-      .map((b) => String((b as Record<string, unknown>)["text"] ?? ""))
-      .join("\n");
-  }
+  // Shape handling moved to `_lib/transcript_entry.ts` so a second reader of the
+  // same field cannot get it wrong. It already did once, in this branch: a
+  // string-only reader saw 0 of the 41 injected skill bodies in this store,
+  // because they all arrive as content blocks.
+  const text = entryText(entry);
   if (!text.trim()) {
     return null;
   }
@@ -102,20 +201,10 @@ export function userText(entry: Entry): string | null {
 
 /** Assistant prose, or null. */
 export function assistantText(entry: Entry): string | null {
-  if (entry["type"] !== "assistant" || entry["isSidechain"] === true) {
-    return null;
-  }
-  const msg = entry["message"];
-  const content = _isObject(msg) ? msg["content"] : undefined;
-  if (!Array.isArray(content)) {
+  if (entry["type"] !== "assistant" || isSidechain(entry)) {
     return null;
   }
-  const text = content
-    .filter((b) => _isObject(b) && b["type"] === "text")
-    .map((b) => String((b as Record<string, unknown>)["text"] ?? ""))
-    .join("\n")
-    .trim();
-  return text || null;
+  return entryText(entry).trim() || null;
 }
 
 /** Tool-use blocks from an assistant entry. */
@@ -228,6 +317,13 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
       if (entry["isCompactSummary"] === true) {
         continue;
       }
+      // A harness-generated turn is not a chat message. The HOOK has skipped
+      // these since round 5 and this scanner did not, so the two were measuring
+      // different populations while reporting one number. Same predicate, one
+      // module, so they cannot drift again.
+      if (isSyntheticPrompt(ut)) {
+        continue;
+      }
       if (isInjectedBody(ut)) {
         // Not a chat message — it changes neither the pin nor the ledger.
         continue;
@@ -328,6 +424,19 @@ export function scanSession(sessionId: string, lines: string[]): SessionReport {
   return report;
 }
 
+/**
+ * Where `--record` appends by default. Under the gitignored `agents/runtime/`
+ * because the series is per-machine observation, and committing it would publish
+ * the project set `storeKey` exists to hide.
+ */
+export const DEFAULT_RATE_SERIES = path.join(
+  REPO_ROOT,
+  "agents",
+  "runtime",
+  "state",
+  "conformance-rates.jsonl",
+);
+
 /** Default Claude Code transcript store for a project directory. */
 export function defaultStore(projectDir: string): string {
   // Claude Code slugs BOTH separators and dots: /Users/x/.claude → -Users-x--claude.
@@ -335,6 +444,51 @@ export function defaultStore(projectDir: string): string {
   return path.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
 }
 
+/** chars/4, the estimate every other payload measurement in this repo uses. */
+function _tokens(chars: number): number {
+  return Math.round(chars / 4);
+}
+
+/**
+ * Measure what each carrier delivers. Defaults are the two real carriers; both
+ * are injectable so a test never reads the developer's home.
+ */
+export function measureDelivered(projectRulesDir: string, globalRulesDir: string): DeliveredPayload {
+  const p = censusRuleDir(projectRulesDir);
+  const g = censusRuleDir(globalRulesDir);
+  return {
+    project: {
+      dir: projectRulesDir,
+      present: fs.existsSync(projectRulesDir),
+      files: p.files,
+      tokens: _tokens(p.chars),
+    },
+    global: {
+      dir: globalRulesDir,
+      present: fs.existsSync(globalRulesDir),
+      files: g.files,
+      tokens: _tokens(g.chars),
+    },
+    union_tokens: _tokens(p.chars + g.chars),
+  };
+}
+
+/**
+ * A stable, non-reversible key for a store — NEVER the path.
+ *
+ * The store path is `-Users-<realname>-projects-<client>-…`: a real name, a
+ * directory layout, and often a customer identifier. `domain-safety-pii` §
+ * Surface 3 forbids exporting a direct identifier and
+ * `low-impact-corpus-privacy-floor` names project-rooted paths outright, so the
+ * forward series is keyed on a digest. It still answers the only question 4.5
+ * asks of it — "is this the same project as last time, and is a FOURTH one
+ * outside the band" — because equality and novelty survive hashing while the
+ * identity does not.
+ */
+export function storeKey(store: string): string {
+  return createHash("sha256").update(path.resolve(store)).digest("hex").slice(0, 12);
+}
+
 export function scanStore(store: string, limit: number): ScanReport {
   const files = fs
     .readdirSync(store)
@@ -365,15 +519,59 @@ export function scanStore(store: string, limit: number): ScanReport {
     }
   }
 
+  const assistant_turns = per_session.reduce((n, s) => n + s.assistant_turns, 0);
+  const language_pin = totals["language-pin"] ?? 0;
+  // Round ONCE, then use the rounded value for both the record and the verdict.
+  // Rounding after the comparison lets a raw 9.06 persist `rate_pct: 9.1` beside
+  // `band: "outside"`, and print "9.1%" directly above "OUTSIDE the 9.1-39.2%
+  // band" — a rounding artefact announcing the declared falsifier.
+  const rate_pct =
+    assistant_turns === 0 ? 0 : Number(((100 * language_pin) / assistant_turns).toFixed(1));
+  const delivered = measureDelivered(
+    path.join(REPO_ROOT, ".claude", "rules"),
+    path.join(process.env["HOME"] ?? os.homedir(), ".claude", "rules"),
+  );
+  const ownStore = path.resolve(store) === path.resolve(defaultStore(REPO_ROOT));
+
   return {
     scanned_at: new Date().toISOString(),
     store,
     sessions: per_session.length,
     totals,
     per_session,
+    delivered,
+    rate: {
+      store_key: storeKey(store),
+      sessions: per_session.length,
+      assistant_turns,
+      language_pin,
+      rate_pct,
+      band: bandVerdict(rate_pct, assistant_turns),
+      // Only attach the carrier figures when the rate and the carriers describe
+      // the same project.
+      delivered_project_tokens: ownStore ? delivered.project.tokens : null,
+      delivered_global_tokens: ownStore ? delivered.global.tokens : null,
+    },
   };
 }
 
+/**
+ * Append one scan's rate record — round-6 Phase 4.5's forward capture.
+ *
+ * PII-exclusion-by-construction, the shape `artifact-engagement-recording`
+ * applies to telemetry: `RateRecord` has NO field able to hold a path, a prompt,
+ * a session id, or any free text, so there is no scrubber here that could fail.
+ * Keep it that way — never widen it with a `note` or `extra`.
+ *
+ * Default destination is under the gitignored `agents/runtime/`, because the
+ * series is per-machine observation and committing it would publish the very
+ * project set the key exists to hide.
+ */
+export function recordRate(file: string, scanned_at: string, rate: RateRecord): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}\n`, "utf8");
+}
+
 export function render(report: ScanReport): string {
   const lines: string[] = [];
   lines.push(`conformance:behavior · ${report.sessions} session(s) · ${report.store}`);
@@ -391,6 +589,45 @@ export function render(report: ScanReport): string {
       lines.push(`    ${s.session}  ${s.violations.length} across ${s.assistant_turns} turns`);
     }
   }
+  const d = report.delivered;
+  lines.push("");
+  lines.push("  Delivered rule text (chars/4, carriers as they stand NOW — not per-session):");
+  const carrier = (label: string, c: { present: boolean; files: number; tokens: number }): string =>
+    c.present
+      ? `    ${label}  ${String(c.files).padStart(4)} rules  ${String(c.tokens).padStart(7)} tok`
+      : `    ${label}  ABSENT — not a measured zero, this carrier does not exist here`;
+  lines.push(carrier("project", d.project));
+  lines.push(carrier("global ", d.global));
+  lines.push(`    union                  ${String(d.union_tokens).padStart(7)} tok`);
+  lines.push("    A session's own payload is NOT recoverable: the transcript records no system");
+  lines.push("    or tools field, and the carriers change under the sessions. This is one");
+  lines.push("    reading; the series below is what makes it interpretable over time.");
+  lines.push("");
+  lines.push(
+    `  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") {
+    lines.push(
+      `    Not compared: ${report.rate.assistant_turns} turns is below the ${BAND_MIN_TURNS} of the`,
+    );
+    lines.push("    smallest corpus the band was derived from, so a verdict here would be about");
+    lines.push("    corpus size, not behaviour.");
+  } else if (report.rate.band === "inside") {
+    lines.push(
+      `    Inside the observed ${OBSERVED_BAND.low}-${OBSERVED_BAND.high}% band (M5, n=3).`,
+    );
+  } else {
+    lines.push(
+      `    ⚠️  OUTSIDE the observed ${OBSERVED_BAND.low}-${OBSERVED_BAND.high}% band (M5, n=3).`,
+    );
+    lines.push("    This is the falsifier both council members named when the volume test was");
+    lines.push("    cancelled: a project outside the band is the signal that the cancellation");
+    lines.push("    was wrong. It is a reason to look, not a defect in this run.");
+    lines.push("    CHECK FIRST that this is a different PROJECT: a git worktree gets its own");
+    lines.push("    transcript store under the same project, so a store-keyed series counts it");
+    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.");
@@ -403,6 +640,7 @@ export function main(argv?: string[]): number {
   let limit = 30;
   let json = false;
   let out: string | null = null;
+  let record: string | null = null;
   for (let i = 0; i < args.length; i += 1) {
     const a = args[i];
     if (a === "--store" && args[i + 1] !== undefined) {
@@ -413,6 +651,13 @@ export function main(argv?: string[]): number {
       json = true;
     } else if (a === "--output" && args[i + 1] !== undefined) {
       out = args[++i] as string;
+    } else if (a === "--record") {
+      // Opt-in, and a bare `--record` takes the default path rather than
+      // swallowing the next flag as a filename.
+      record =
+        args[i + 1] !== undefined && !(args[i + 1] as string).startsWith("-")
+          ? (args[++i] as string)
+          : DEFAULT_RATE_SERIES;
     }
   }
   const resolved = store ?? defaultStore(process.cwd());
@@ -424,6 +669,9 @@ export function main(argv?: string[]): number {
   if (out) {
     fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`, "utf8");
   }
+  if (record) {
+    recordRate(record, report.scanned_at, report.rate);
+  }
   // fs.writeSync, not process.stdout.write: `process.exit()` below does not
   // flush an async pipe write, so `--json | jq` reproducibly received a
   // truncated 64 KB document with no error (measured: 85,169 vs 65,536 bytes).