@event4u/agent-config 8.10.0 → 8.12.0

package/src/scripts/ai_tells_rules.ts

@@ -0,0 +1,433 @@
+#!/usr/bin/env node
+/**
+ * ai_tells_rules — deterministic AI-writing-tell registry for prose deliverables.
+ *
+ * Data + matchers for the mechanically detectable subset of the AI-writing
+ * pattern catalog in `src/skills/humanizer/data/patterns.md` (root source:
+ * Wikipedia "Signs of AI writing", WikiProject AI Cleanup). Mirrors the
+ * `design_slop_rules.ts` split: this file is the registry, `detect_ai_tells.ts`
+ * is the CLI. Scope is GENERATED DELIVERABLE PROSE (ghostwriter drafts, posts,
+ * articles) — NEVER repo docs; this repo's own documentation style (em dashes,
+ * bold inline headers) is intentional and exempt by scope, not by allowlist.
+ *
+ * Severity model (encodes the source catalog's false-positive guidance —
+ * "clusters are a confession, isolated hits are not"):
+ *   hard    — a single hit counts against `--max-hard` (chat artifacts,
+ *             knowledge-cutoff disclaimers, emoji headings, ` -- ` asides).
+ *   cluster — hits contribute `weight` to a per-500-words score gated by
+ *             `--max-score` (AI vocabulary, filler, hedging, sycophancy, …).
+ *   Em/en dashes are a DENSITY rule (per-500-words cap, default 2 — CP1
+ *   parity from design-antipatterns), never hard-zero: council 2026-07-11
+ *   rejected the zero-dash rule; a captured voice fingerprint that
+ *   legitimately uses dashes wins (suppression happens at the call site).
+ *
+ * Dependency-free by design (npx-shipped package) — pattern analysis only.
+ */
+
+export type TellSeverity = "hard" | "cluster";
+export type TellGroup =
+  | "content"
+  | "language"
+  | "style"
+  | "communication"
+  | "filler";
+/** "any" = language-agnostic (typography / structure tells). */
+export type TellLanguage = "en" | "de" | "any";
+
+export interface TellRule {
+  id: string;
+  group: TellGroup;
+  severity: TellSeverity;
+  language: TellLanguage;
+  /** cluster weight per hit; ignored for hard rules */
+  weight: number;
+  description: string;
+  patterns: RegExp[];
+}
+
+/** Em/en-dash density cap per 500 words (CP1 parity). */
+export const DEFAULT_MAX_DASH_DENSITY = 2;
+/** Weighted cluster-score cap per 500 words. */
+export const DEFAULT_MAX_CLUSTER_SCORE = 3;
+/** Hard-hit cap. */
+export const DEFAULT_MAX_HARD = 0;
+
+const w = (
+  id: string,
+  group: TellGroup,
+  severity: TellSeverity,
+  language: TellLanguage,
+  weight: number,
+  description: string,
+  patterns: RegExp[],
+): TellRule => ({ id, group, severity, language, weight, description, patterns });
+
+export const TELL_RULES: TellRule[] = [
+  // ── hard: communication artifacts pasted into a deliverable ──────────────
+  w(
+    "tell-chat-artifact",
+    "communication",
+    "hard",
+    "en",
+    0,
+    "Chatbot correspondence pasted as content (I hope this helps / let me know / would you like…)",
+    [
+      /\bI hope this helps\b/i,
+      /\blet me know if you('| wou)?l?d? like\b/i,
+      /\bwould you like me to\b/i,
+      /\bwant me to (give|continue|expand)\b/i,
+      /\bshould I continue\b/i,
+      /\bhere('s| is) (an? )?(overview|breakdown|summary) of\b/i,
+    ],
+  ),
+  w(
+    "tell-knowledge-cutoff",
+    "communication",
+    "hard",
+    "en",
+    0,
+    "Knowledge-cutoff disclaimer or speculative gap-filling presented as fact",
+    [
+      /\bas of my (last|latest) (update|training)\b/i,
+      /\bmy knowledge cutoff\b/i,
+      /\bup to my last training update\b/i,
+      /\bwhile specific details are (limited|scarce|not extensively documented)\b/i,
+      /\bbased on (the )?available information\b/i,
+      /\b(maintains a low profile|keeps personal details private)\b/i,
+    ],
+  ),
+  w(
+    "tell-emoji-heading",
+    "style",
+    "hard",
+    "any",
+    0,
+    "Emoji-decorated heading or bold list header",
+    [
+      /^#{1,6}\s*[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}]/mu,
+      /^\s*[-*]?\s*[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}]\s*\*\*/mu,
+    ],
+  ),
+  w(
+    "tell-double-hyphen-aside",
+    "style",
+    "hard",
+    "any",
+    0,
+    "Spaced double hyphen used as an em-dash substitute",
+    [/\s--\s/],
+  ),
+
+  // ── cluster: post-2023 AI vocabulary & copula avoidance ──────────────────
+  w(
+    "tell-ai-vocabulary",
+    "language",
+    "cluster",
+    "en",
+    1,
+    "Overused post-2023 AI vocabulary (delve, tapestry, showcase, pivotal, …)",
+    [
+      /\bdelve(s|d)?\b/i,
+      /\btapestry\b/i,
+      /\bshowcas(e|es|ing)\b/i,
+      /\btestament to\b/i,
+      /\bpivotal\b/i,
+      /\bcrucial role\b/i,
+      /\bvibrant\b/i,
+      /\bintricate\b/i,
+      /\binterplay\b/i,
+      /\bfostering\b/i,
+      /\bgarner(ed|s)?\b/i,
+      /\bever-evolving\b/i,
+      /\bevolving landscape\b/i,
+      /\b(digital|competitive|cultural) landscape\b/i,
+      /\bnestled\b/i,
+      /\bboasts?\b/i,
+      /\bunderscore(s|d)?\b/i,
+      /\bgroundbreaking\b/i,
+      /\bseamless(ly)?\b/i,
+      /\belevate(s|d)? your\b/i,
+    ],
+  ),
+  w(
+    "tell-copula-avoidance",
+    "language",
+    "cluster",
+    "en",
+    1,
+    "Elaborate constructions replacing a simple 'is' (serves as / stands as / represents a)",
+    [
+      /\bserves as an?\b/i,
+      /\bstands as an?\b/i,
+      /\bmarks an? (pivotal|significant|key|major)\b/i,
+      /\brepresents an? (shift|milestone|step)\b/i,
+    ],
+  ),
+  w(
+    "tell-significance-inflation",
+    "content",
+    "cluster",
+    "en",
+    1,
+    "Inflated significance / legacy framing (pivotal moment, broader trends, setting the stage)",
+    [
+      /\bpivotal moment\b/i,
+      /\bbroader (trend|movement|shift)s?\b/i,
+      /\bsetting the stage for\b/i,
+      /\bindelible mark\b/i,
+      /\bkey turning point\b/i,
+      /\bdeeply rooted\b/i,
+      /\benduring (legacy|spirit|impact)\b/i,
+      /\bplays? a (crucial|vital|key|pivotal) role\b/i,
+      /\bunderscores? (its|the) (importance|significance)\b/i,
+    ],
+  ),
+  w(
+    "tell-negative-parallelism",
+    "language",
+    "cluster",
+    "en",
+    1,
+    "Not just X — it's Y constructions and tailing negations",
+    [
+      /\b(is|it'?s) not (just|only|merely) about\b/i,
+      /\bnot (just|only|merely) an?\b[^.!?\n]{3,80}\b(but|it'?s)\b/i,
+      /\bisn'?t (just|only|merely)\b/i,
+      /,\s*no (guessing|fluff|wasted \w+)[.!]?$/im,
+    ],
+  ),
+  w(
+    "tell-false-range",
+    "language",
+    "cluster",
+    "en",
+    0.5,
+    "'From X to Y' constructions where X and Y are not on a scale",
+    [/\bfrom [^,.\n]{3,45} to [^,.\n]{3,45},\s*(?:and\s+)?from\b/i],
+  ),
+  w(
+    "tell-rule-of-three",
+    "language",
+    "cluster",
+    "any",
+    0.5,
+    "Forced triplet groupings (innovation, inspiration, and insights)",
+    [/\b\w+(?:ity|ion|ness|ing|s)?, \w+(?:ity|ion|ness|ing|s)?, and \w+/],
+  ),
+
+  // ── cluster: filler, hedging, endings, openers ───────────────────────────
+  w(
+    "tell-filler-phrase",
+    "filler",
+    "cluster",
+    "en",
+    1,
+    "Filler phrases (in order to, due to the fact that, it is important to note)",
+    [
+      /\bin order to\b/i,
+      /\bdue to the fact that\b/i,
+      /\bat this point in time\b/i,
+      /\bin the event that\b/i,
+      /\bhas the ability to\b/i,
+      /\bit('s| is) (important|worth) (to note|noting) that\b/i,
+    ],
+  ),
+  w(
+    "tell-hedging-stack",
+    "filler",
+    "cluster",
+    "en",
+    1,
+    "Stacked hedges (could potentially, might possibly)",
+    [
+      /\bcould potentially\b/i,
+      /\bmight possibly\b/i,
+      /\bit could be argued that\b/i,
+      /\bperhaps one of the most\b/i,
+    ],
+  ),
+  w(
+    "tell-generic-conclusion",
+    "filler",
+    "cluster",
+    "en",
+    1,
+    "Generic upbeat endings (the future looks bright, exciting times ahead)",
+    [
+      /\bthe future (looks|is) bright\b/i,
+      /\bexciting times (lie )?ahead\b/i,
+      /\bstep in the right direction\b/i,
+      /\bjourney (toward|towards)\b/i,
+      /\bcontinues? to thrive\b/i,
+      /\bpromises? memories\b/i,
+    ],
+  ),
+  w(
+    "tell-signposting",
+    "filler",
+    "cluster",
+    "en",
+    1,
+    "Announcement-style signposting (let's dive in, here's what you need to know)",
+    [
+      /\blet'?s dive (in|into)\b/i,
+      /\blet'?s explore\b/i,
+      /\blet'?s break (this|it) down\b/i,
+      /\bwithout further ado\b/i,
+      /\bhere'?s what you need to know\b/i,
+    ],
+  ),
+  w(
+    "tell-authority-trope",
+    "filler",
+    "cluster",
+    "en",
+    1,
+    "Persuasive authority tropes (the real question is, at its core)",
+    [
+      /\bthe real question is\b/i,
+      /\bat its core\b/i,
+      /\bwhat really matters is\b/i,
+      /\bthe heart of the matter\b/i,
+      /\bthe deeper issue\b/i,
+    ],
+  ),
+  w(
+    "tell-sycophancy",
+    "communication",
+    "cluster",
+    "en",
+    1,
+    "Sycophantic openers (great question, you're absolutely right)",
+    [
+      /\bgreat question\b/i,
+      /\byou'?re absolutely right\b/i,
+      /\b(that'?s an? )?excellent point\b/i,
+    ],
+  ),
+  w(
+    "tell-vague-attribution",
+    "content",
+    "cluster",
+    "en",
+    1,
+    "Weasel-word attributions (experts argue, observers have cited, industry reports)",
+    [
+      /\bexperts (argue|believe|suggest|agree)\b/i,
+      /\bobservers have (cited|noted)\b/i,
+      /\bindustry reports\b/i,
+      /\bsome critics argue\b/i,
+      /\bwidely (regarded|considered) as\b/i,
+    ],
+  ),
+  w(
+    "tell-aphorism-formula",
+    "filler",
+    "cluster",
+    "en",
+    1,
+    "Aphorism formulas (X is the language/currency/architecture of Z, X becomes a trap)",
+    [
+      /\bis the (language|currency|architecture|lifeblood) of\b/i,
+      /\bbecomes a trap\b/i,
+      /\bis not a tool but a mirror\b/i,
+    ],
+  ),
+
+  // ── cluster: typography / structure (language-agnostic) ──────────────────
+  w(
+    "tell-curly-quotes",
+    "style",
+    "cluster",
+    "any",
+    0.25,
+    "Curly quotation marks (only meaningful in clusters — editors auto-curl)",
+    [/[“”‘’]/],
+  ),
+  w(
+    "tell-bold-header-list",
+    "style",
+    "cluster",
+    "any",
+    1,
+    "Vertical list items opening with a bolded header + colon",
+    [/^\s*[-*]\s+\*\*[^*\n]{2,60}:?\*\*:?\s/m],
+  ),
+  w(
+    "tell-title-case-heading",
+    "style",
+    "cluster",
+    "en",
+    0.5,
+    "Title-Case Headings With Every Word Capitalized",
+    [/^#{2,6}\s+(?:[A-Z][a-z]+\s+){3,}[A-Z][a-z]+\s*$/m],
+  ),
+];
+
+// ── German subset (language: de) — added under the de-subset-demand gate ────
+export const TELL_RULES_DE: TellRule[] = [
+  w(
+    "tell-de-filler",
+    "filler",
+    "cluster",
+    "de",
+    1,
+    "Deutsche Füllphrasen (es ist wichtig zu beachten, im heutigen digitalen Zeitalter)",
+    [
+      /\bes ist wichtig(,)? zu (beachten|betonen|erwähnen)\b/i,
+      /\bim heutigen digitalen Zeitalter\b/i,
+      /\bin der heutigen schnelllebigen (Welt|Zeit)\b/i,
+      /\bes sei darauf hingewiesen\b/i,
+    ],
+  ),
+  w(
+    "tell-de-connector-stack",
+    "language",
+    "cluster",
+    "de",
+    1,
+    "Konnektoren-Stapel (zudem, darüber hinaus, des Weiteren)",
+    [
+      /\bzudem\b/i,
+      /\bdar(ü|ue)ber hinaus\b/i,
+      /\bdes Weiteren\b/i,
+      /\bnicht zuletzt\b/i,
+    ],
+  ),
+  w(
+    "tell-de-significance",
+    "content",
+    "cluster",
+    "de",
+    1,
+    "Bedeutungs-Inflation (spielt eine entscheidende Rolle, markiert einen Wendepunkt)",
+    [
+      /\bspielt eine (entscheidende|zentrale|wichtige|Schl(ü|ue)ssel)rolle\b/i,
+      /\bmarkiert einen (Wendepunkt|Meilenstein)\b/i,
+      /\bunterstreicht die Bedeutung\b/i,
+      /\bein Meilenstein (in|f(ü|ue)r)\b/i,
+      /\bnahtlos(e|es|er)?\b/i,
+    ],
+  ),
+  w(
+    "tell-de-negative-parallelism",
+    "language",
+    "cluster",
+    "de",
+    1,
+    "Nicht nur X, sondern Y",
+    [/\bnicht nur\b[^.!?\n]{3,80}\bsondern( auch)?\b/i],
+  ),
+];
+
+/** Every registry rule, both languages. */
+export const ALL_TELL_RULES: TellRule[] = [...TELL_RULES, ...TELL_RULES_DE];
+
+/** Crude language sniff for `--language auto`: DE stopword density. */
+export function sniffLanguage(text: string): "en" | "de" {
+  const deHits =
+    text.match(/\b(und|nicht|eine?|der|die|das|mit|für|ist|wird|auch)\b/gi)
+      ?.length ?? 0;
+  const words = text.split(/\s+/).filter(Boolean).length || 1;
+  return deHits / words > 0.04 ? "de" : "en";
+}

package/src/scripts/bench_humanizer_eval.ts

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+/**
+ * bench_humanizer_eval — paired eval for the humanizer feature.
+ *
+ * Two metrics over the before/after corpus in `tests/fixtures/ai-tells/`:
+ *
+ *   1. OBJECTIVE (free, deterministic): AI-tell reduction per pair via
+ *      `detect_ai_tells.ts` — hard hits, cluster score/500w, dash density/500w.
+ *   2. BLIND PREFERENCE (--judge, billable): an LLM judge sees each pair in
+ *      randomized A/B order (deterministic LCG seed per pair) and picks which
+ *      text reads more like a skilled human writer. LENGTH-CONTROLLED: pairs
+ *      whose word counts differ by more than ±25% are excluded from the
+ *      preference aggregate (the token program's verbosity-bias finding makes
+ *      uncontrolled pairs unusable) — they still count for the objective metric.
+ *
+ * Reports follow docs/benchmarks.md naming:
+ *   internal/bench/reports/humanizer-v1.{json,md}          (canonical pointer)
+ *   internal/bench/reports/<ISO>-humanizer-v1.{json,md}    (immutable trail)
+ *
+ * Claims discipline: this eval backs `claim:humanizer-tell-reduction` in
+ * docs/CLAIMS.md. It measures OUR pattern counts and a blind preference —
+ * never third-party "AI detector" outcomes; that claim class stays banned.
+ *
+ * Usage:
+ *   npx tsx src/scripts/bench_humanizer_eval.ts                          # objective only (free)
+ *   npx tsx src/scripts/bench_humanizer_eval.ts --judge --confirm-spend  # + blind preference (billable)
+ *
+ * `--judge` without `--confirm-spend` estimates the billable call count and
+ * halts (exit 2) — the spend is opt-in, never fired implicitly.
+ */
+
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { analyzeText, type TellReport } from "./detect_ai_tells.js";
+
+const ROOT = process.cwd();
+const FIXTURES = join(ROOT, "tests", "fixtures", "ai-tells");
+const REPORT_DIR = join(ROOT, "internal", "bench", "reports");
+const LENGTH_TOLERANCE = 0.25;
+
+interface PairResult {
+  name: string;
+  language: "en" | "de";
+  words_before: number;
+  words_after: number;
+  length_ratio: number;
+  length_controlled: boolean;
+  before: Pick<TellReport, "hard_total" | "cluster_score_per_500" | "dash_density_per_500">;
+  after: Pick<TellReport, "hard_total" | "cluster_score_per_500" | "dash_density_per_500">;
+  judge?: { preferred: "after" | "before"; order: "after-first" | "before-first" };
+}
+
+function slim(r: TellReport) {
+  return {
+    hard_total: r.hard_total,
+    cluster_score_per_500: r.cluster_score_per_500,
+    dash_density_per_500: r.dash_density_per_500,
+  };
+}
+
+/** Deterministic per-pair coin flip (LCG) so re-runs keep the same A/B order. */
+function coin(seed: number): boolean {
+  return ((seed * 1103515245 + 12345) >>> 16) % 2 === 0;
+}
+
+function loadPairs(): Array<{ name: string; language: "en" | "de"; before: string; after: string }> {
+  const out: Array<{ name: string; language: "en" | "de"; before: string; after: string }> = [];
+  for (const language of ["en", "de"] as const) {
+    const dir = join(FIXTURES, language);
+    let names: string[] = [];
+    try {
+      names = readdirSync(dir)
+        .filter((f) => f.endsWith(".before.md"))
+        .map((f) => f.replace(/\.before\.md$/, ""))
+        .sort();
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      out.push({
+        name,
+        language,
+        before: readFileSync(join(dir, `${name}.before.md`), "utf8"),
+        after: readFileSync(join(dir, `${name}.after.md`), "utf8"),
+      });
+    }
+  }
+  return out;
+}
+
+async function judgePair(
+  pair: { name: string; before: string; after: string },
+  index: number,
+): Promise<{ preferred: "after" | "before"; order: "after-first" | "before-first" }> {
+  const { AnthropicClient, load_anthropic_key } = await import("./ai_council/clients.js");
+  const client = new AnthropicClient({ api_key: load_anthropic_key() });
+  const afterFirst = coin(index + 1);
+  const [a, b] = afterFirst ? [pair.after, pair.before] : [pair.before, pair.after];
+  const system =
+    "You judge writing quality blind. You will see two texts, A and B, covering the same content. " +
+    "Pick the one that reads more like it was written by a skilled human writer for a real audience. " +
+    "Judge prose quality only — not length, not topic. Reply with exactly one character: A or B.";
+  const user = `Text A:\n\n${a}\n\n---\n\nText B:\n\n${b}\n\nWhich reads more like a skilled human writer? Reply A or B.`;
+  const resp = client.ask(system, user, 8);
+  const text = (resp.text ?? "").trim().toUpperCase();
+  const pickedA = text.startsWith("A");
+  const preferred = pickedA === afterFirst ? "after" : "before";
+  return { preferred, order: afterFirst ? "after-first" : "before-first" };
+}
+
+async function main(): Promise<void> {
+  const runJudge = process.argv.includes("--judge");
+  const confirmSpend = process.argv.includes("--confirm-spend");
+  const pairs = loadPairs();
+  if (pairs.length < 20) {
+    console.error(`corpus too small: ${pairs.length} pairs (< 20)`);
+    process.exit(2);
+  }
+
+  // Spend gate: --judge fires one billable API call per length-controlled
+  // pair (via the council client's curl transport). Estimate + halt unless
+  // --confirm-spend is passed — mirrors council:run's explicit-confirm model,
+  // never an interactive prompt. The objective-only default path is free.
+  if (runJudge && !confirmSpend) {
+    const controlledCount = pairs.filter((p) => {
+      const b = analyzeText(p.before, p.language).words;
+      const a = analyzeText(p.after, p.language).words;
+      return Math.abs(1 - a / b) <= LENGTH_TOLERANCE;
+    }).length;
+    process.stderr.write(
+      `--judge makes ${controlledCount} billable API call(s) (one per length-controlled pair). ` +
+        `Re-run with --confirm-spend to authorize the spend. ` +
+        `The objective-only run (no --judge) is free.\n`,
+    );
+    process.exit(2);
+  }
+
+  const results: PairResult[] = [];
+  for (let i = 0; i < pairs.length; i++) {
+    const p = pairs[i]!;
+    const before = analyzeText(p.before, p.language);
+    const after = analyzeText(p.after, p.language);
+    const ratio = after.words / before.words;
+    const controlled = Math.abs(1 - ratio) <= LENGTH_TOLERANCE;
+    const row: PairResult = {
+      name: p.name,
+      language: p.language,
+      words_before: before.words,
+      words_after: after.words,
+      length_ratio: Math.round(ratio * 100) / 100,
+      length_controlled: controlled,
+      before: slim(before),
+      after: slim(after),
+    };
+    if (runJudge && controlled) {
+      row.judge = await judgePair(p, i);
+      process.stdout.write(`  judged ${p.name}: prefers ${row.judge.preferred} (${row.judge.order})\n`);
+    }
+    results.push(row);
+  }
+
+  const mean = (xs: number[]) =>
+    Math.round((xs.reduce((s, x) => s + x, 0) / Math.max(xs.length, 1)) * 100) / 100;
+  const agg = {
+    pairs: results.length,
+    length_controlled_pairs: results.filter((r) => r.length_controlled).length,
+    mean_hard_before: mean(results.map((r) => r.before.hard_total)),
+    mean_hard_after: mean(results.map((r) => r.after.hard_total)),
+    mean_cluster_before: mean(results.map((r) => r.before.cluster_score_per_500)),
+    mean_cluster_after: mean(results.map((r) => r.after.cluster_score_per_500)),
+    mean_dash_before: mean(results.map((r) => r.before.dash_density_per_500)),
+    mean_dash_after: mean(results.map((r) => r.after.dash_density_per_500)),
+    judge_model: undefined as string | undefined,
+    judged_pairs: 0,
+    prefers_after: 0,
+    prefers_before: 0,
+  };
+  const judged = results.filter((r) => r.judge);
+  agg.judged_pairs = judged.length;
+  agg.prefers_after = judged.filter((r) => r.judge!.preferred === "after").length;
+  agg.prefers_before = judged.filter((r) => r.judge!.preferred === "before").length;
+  if (runJudge) {
+    const { DEFAULT_ANTHROPIC_MODEL } = await import("./ai_council/clients.js");
+    agg.judge_model = DEFAULT_ANTHROPIC_MODEL as string;
+  }
+
+  const iso = new Date().toISOString().replace(/\.\d+Z$/, "Z").replace(/:/g, "-");
+  const payload = { generated: iso, corpus: "tests/fixtures/ai-tells", aggregate: agg, results };
+
+  const md = [
+    "# Humanizer paired eval — v1",
+    "",
+    `> Generated ${iso} · corpus \`tests/fixtures/ai-tells\` (${agg.pairs} before/after pairs, ` +
+      `${agg.length_controlled_pairs} length-controlled ±${LENGTH_TOLERANCE * 100}%).`,
+    "",
+    "## Objective — AI-tell reduction (deterministic)",
+    "",
+    "| Metric (mean) | Before | After |",
+    "|---|---|---|",
+    `| Hard hits | ${agg.mean_hard_before} | ${agg.mean_hard_after} |`,
+    `| Cluster score /500w | ${agg.mean_cluster_before} | ${agg.mean_cluster_after} |`,
+    `| Dash density /500w | ${agg.mean_dash_before} | ${agg.mean_dash_after} |`,
+    "",
+    "## Blind preference (length-controlled)",
+    "",
+    agg.judged_pairs > 0
+      ? `Judge ${agg.judge_model}: prefers the humanized text in **${agg.prefers_after}/${agg.judged_pairs}** ` +
+        `pairs (randomized A/B order, deterministic seed). An honest null here keeps the detector as a ` +
+        `hygiene gate; the claim ledger only carries what this table shows.`
+      : "_Not run (objective-only invocation)._",
+    "",
+    "## Scope note",
+    "",
+    "This eval measures the package's own pattern counts and a blind prose-quality preference.",
+    'It never measures third-party "AI detector" outcomes — that claim class is banned',
+    "(unfalsifiable from our side; see roadmap non-goals).",
+    "",
+    "## Open question — real-draft lift is unmeasured",
+    "",
+    "The `before` fixtures were **deliberately tell-seeded**, so a perfect score",
+    "measures seeded-tell removal on a self-constructed corpus — NOT that real",
+    "ghostwriter drafts get better. Real-world lift stays **unmeasured** until",
+    "write-engine step 4b has processed real `/ghostwriter:write` drafts and those",
+    "have been paired-evaluated (the `road-to-humanizer-hardening` live-usage",
+    "blocker). The claim ledger is scoped to \"on the fixture corpus\" accordingly.",
+    "",
+  ].join("\n");
+
+  mkdirSync(REPORT_DIR, { recursive: true });
+  writeFileSync(join(REPORT_DIR, "humanizer-v1.json"), JSON.stringify(payload, null, 2));
+  writeFileSync(join(REPORT_DIR, "humanizer-v1.md"), md);
+  writeFileSync(join(REPORT_DIR, `${iso}-humanizer-v1.json`), JSON.stringify(payload, null, 2));
+  writeFileSync(join(REPORT_DIR, `${iso}-humanizer-v1.md`), md);
+  process.stdout.write(md + "\n");
+}
+
+main().catch((err) => {
+  console.error(String(err));
+  process.exit(2);
+});