@event4u/agent-config 14.11.0 → 14.13.0

package/src/scripts/_lib/asset_delivery_ledger.ts

@@ -0,0 +1,303 @@
+/**
+ * Per-asset delivery ledger — which assets produce the standing payload
+ * (`road-to-delivered-cost-truth` step 2.1).
+ *
+ * `check_preamble_payload_budget` measures three BUCKET totals and refuses
+ * growth. It cannot say which asset inside a bucket is producing the cost, so a
+ * reduction effort has a number and no target. This module ranks the assets.
+ *
+ * WHAT "DELIVERY" MEANS PER BUCKET, because the two are not the same shape:
+ *
+ * - a RULE in the standing set delivers its whole body on every spawn;
+ * - a SKILL delivers only its catalogue line — `- <name>: <description>` — on
+ *   every spawn. Its body is loaded on activation, which is not standing cost
+ *   and is deliberately not counted here.
+ *
+ * Ranking the two together without that distinction would put every skill body
+ * above every rule and send a reduction effort at the wrong half of the tree.
+ *
+ * MEASUREMENT HONESTY. Each row states whether it was measured with the exact
+ * BPE tokenizer or the `chars/4` proxy, and a proxy reading within its own error
+ * margin of a threshold is reported `unresolved` rather than classified — the
+ * discipline `lint_token_budget_discipline` already applies to the rich band,
+ * reused here rather than reinvented.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { parseFrontmatter } from '../preamble_byte_census.js';
+import { gpt_tokens, gpt_tokens_proxy } from './token_count.js';
+
+/** Worst-case per-file error of the character proxy, as measured for the rich band. */
+export const PROXY_ERROR_MARGIN = 0.06;
+
+export type AssetKind = 'rule' | 'skill-catalogue-line';
+
+export interface AssetRow {
+    /** Repo-relative path of the asset. */
+    file: string;
+    /** Asset name as the preamble names it. */
+    name: string;
+    kind: AssetKind;
+    /** Tokens this asset contributes to EVERY spawn. */
+    tokens: number;
+    /**
+     * The same asset under the `chars/4` proxy.
+     *
+     * Carried alongside the BPE figure, not instead of it, because the payload
+     * gate counts chars/4 and reconciling a BPE total against a chars/4 total
+     * measures the METHODS, not the ledger. See {@link reconcile}.
+     */
+    proxy_tokens: number;
+    /** `exact` when the BPE tokenizer resolved, `proxy` otherwise. */
+    method: 'exact' | 'proxy';
+    /** Share of the ledger total. */
+    share: number;
+}
+
+export interface LedgerVerdict {
+    rows: AssetRow[];
+    total_tokens: number;
+    /** True only when EVERY row came from the exact tokenizer. */
+    exact_throughout: boolean;
+    by_kind: Record<AssetKind, { count: number; tokens: number; proxy_tokens: number }>;
+}
+
+/**
+ * Is a proxy reading too close to `threshold` to be classified?
+ *
+ * Symmetric, deliberately: the measured proxy error runs in BOTH directions
+ * (−5.3 % on the largest rich artifact), so a band that straddles the threshold
+ * yields no verdict rather than a confident wrong one.
+ */
+export function unresolvedAgainst(tokens: number, method: 'exact' | 'proxy', threshold: number): boolean {
+    if (method === 'exact') return false;
+    const margin = Math.ceil(tokens * PROXY_ERROR_MARGIN);
+    return tokens - margin <= threshold && tokens + margin > threshold;
+}
+
+/** Walk the standing rule directory. Each rule delivers its whole body. */
+export function measureRules(rulesDir: string, repoRoot: string): AssetRow[] {
+    if (!fs.existsSync(rulesDir)) return [];
+    const rows: AssetRow[] = [];
+    for (const entry of fs.readdirSync(rulesDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+        const abs = path.join(rulesDir, entry.name);
+        const text = fs.readFileSync(abs, 'utf-8');
+        const count = gpt_tokens(text);
+        rows.push({
+            file: path.relative(repoRoot, abs),
+            name: entry.name.replace(/\.md$/, ''),
+            kind: 'rule',
+            tokens: count.tokens,
+            proxy_tokens: gpt_tokens_proxy(text).tokens,
+            method: count.exact ? 'exact' : 'proxy',
+            share: 0,
+        });
+    }
+    return rows;
+}
+
+/**
+ * Walk the skill catalogue. Each skill delivers ONE line, not its body.
+ *
+ * The line is built the same way `censusSkillsCatalog` builds it — `- <name>:
+ * <description>\n` — because a ledger that measured the body would rank a skill
+ * that is never activated above a rule that is always delivered.
+ */
+export function measureSkillCatalogue(skillsDir: string, repoRoot: string): AssetRow[] {
+    if (!fs.existsSync(skillsDir)) return [];
+    const rows: AssetRow[] = [];
+    for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const skillMd = path.join(skillsDir, entry.name, 'SKILL.md');
+        let text: string;
+        try {
+            text = fs.readFileSync(skillMd, 'utf-8');
+        } catch {
+            continue;
+        }
+        // The SAME parser the payload census uses, not a second reader of the
+        // same bytes. A regex version reconciled 17.1 % low because a folded
+        // multi-line `description:` truncates at the first newline.
+        const fm = parseFrontmatter(text);
+        const name = typeof fm.name === 'string' && fm.name.length > 0 ? fm.name : entry.name;
+        const description = typeof fm.description === 'string' ? fm.description : '';
+        const line = `- ${name}: ${description}\n`;
+        const count = gpt_tokens(line);
+        rows.push({
+            file: path.relative(repoRoot, skillMd),
+            name,
+            kind: 'skill-catalogue-line',
+            tokens: count.tokens,
+            proxy_tokens: gpt_tokens_proxy(line).tokens,
+            method: count.exact ? 'exact' : 'proxy',
+            share: 0,
+        });
+    }
+    return rows;
+}
+
+export function buildLedger(rulesDir: string, skillsDir: string, repoRoot: string): LedgerVerdict {
+    const rows = [...measureRules(rulesDir, repoRoot), ...measureSkillCatalogue(skillsDir, repoRoot)];
+    const total = rows.reduce((n, r) => n + r.tokens, 0);
+    for (const r of rows) r.share = total > 0 ? r.tokens / total : 0;
+    rows.sort((a, b) => b.tokens - a.tokens || a.file.localeCompare(b.file));
+
+    const byKind: Record<AssetKind, { count: number; tokens: number; proxy_tokens: number }> = {
+        rule: { count: 0, tokens: 0, proxy_tokens: 0 },
+        'skill-catalogue-line': { count: 0, tokens: 0, proxy_tokens: 0 },
+    };
+    for (const r of rows) {
+        byKind[r.kind].count += 1;
+        byKind[r.kind].tokens += r.tokens;
+        byKind[r.kind].proxy_tokens += r.proxy_tokens;
+    }
+    return { rows, total_tokens: total, exact_throughout: rows.every((r) => r.method === 'exact'), by_kind: byKind };
+}
+
+export interface Reconciliation {
+    kind: AssetKind;
+    bucket: string;
+    /** The ledger's chars/4 total — the SAME method the bucket uses. */
+    ledger_proxy_tokens: number;
+    /** The ledger's BPE total, reported for contrast, never reconciled against. */
+    ledger_exact_tokens: number;
+    bucket_tokens: number;
+    /** Absolute relative difference, like-for-like. */
+    drift: number;
+    within_margin: boolean;
+}
+
+/**
+ * Reconcile the ledger against the payload gate's own bucket totals.
+ *
+ * LIKE-FOR-LIKE, and this took a correction. The first cut compared the
+ * ledger's BPE total against the gate's `chars/4` bucket and set a 15 % margin
+ * to absorb the difference. That margin was GUESSED, which is the exact defect
+ * this roadmap's own budget file is careful about — and it did not even work:
+ * rules reconciled at 1.6 % while skill catalogue lines drifted 28.1 %, because
+ * `chars/4` overestimates short structured lines far more than it does prose.
+ * The 15 % would have hidden the rule drift and failed the skill drift, and
+ * neither verdict would have been about the ledger.
+ *
+ * So the ledger carries BOTH figures and reconciles the proxy against the
+ * proxy. What remains is real disagreement — a different corpus, a different
+ * line format, a missed file — which is what a reconciliation is for. The
+ * margin can then be tight, because two implementations of one arithmetic
+ * should agree closely or one of them is wrong.
+ */
+export const RECONCILE_MARGIN = 0.02;
+
+export function reconcile(
+    ledger: LedgerVerdict,
+    buckets: ReadonlyArray<{ name: string; tokens: number }>,
+): Reconciliation[] {
+    const map: Array<{ kind: AssetKind; bucket: string }> = [
+        { kind: 'rule', bucket: 'project-scope rules' },
+        { kind: 'skill-catalogue-line', bucket: 'preloaded skills catalog' },
+    ];
+    const out: Reconciliation[] = [];
+    for (const m of map) {
+        const bucket = buckets.find((b) => b.name === m.bucket);
+        if (bucket === undefined) continue;
+        const proxyTokens = ledger.by_kind[m.kind].proxy_tokens;
+        const drift =
+            bucket.tokens === 0 ? (proxyTokens === 0 ? 0 : 1) : Math.abs(proxyTokens - bucket.tokens) / bucket.tokens;
+        out.push({
+            kind: m.kind,
+            bucket: m.bucket,
+            ledger_proxy_tokens: proxyTokens,
+            ledger_exact_tokens: ledger.by_kind[m.kind].tokens,
+            bucket_tokens: bucket.tokens,
+            drift,
+            within_margin: drift <= RECONCILE_MARGIN,
+        });
+    }
+    return out;
+}
+
+// ─────────────────────────────────────────── growth attribution (step 2.2)
+
+export interface GrowthEntry {
+    name: string;
+    kind: AssetKind;
+    /** Positive = this asset grew or arrived. */
+    delta: number;
+    status: 'added' | 'grew' | 'shrank' | 'removed';
+}
+
+export interface GrowthAttribution {
+    /** Assets that grew or arrived, largest first. */
+    increases: GrowthEntry[];
+    /** Assets that shrank or left, largest saving first. */
+    decreases: GrowthEntry[];
+    net_delta: number;
+}
+
+/**
+ * Attribute a payload change to the assets that caused it (step 2.2).
+ *
+ * A ratchet that says "the payload grew past the ceiling" states a fact and
+ * leaves the reader to find the cause; the same refusal naming the asset and its
+ * token delta reads as a quantified saving instead of an obstacle. That is the
+ * whole difference this function buys, and it is a presentation difference with
+ * a real consequence: a refusal nobody can act on gets suppressed rather than
+ * fixed.
+ *
+ * Pure and order-independent — both sides are keyed on `kind:name`, so a
+ * reordered ledger produces the same attribution.
+ */
+export function attributeGrowth(before: readonly AssetRow[], after: readonly AssetRow[]): GrowthAttribution {
+    const key = (r: AssetRow): string => `${r.kind}:${r.name}`;
+    const b = new Map(before.map((r) => [key(r), r.tokens]));
+    const a = new Map(after.map((r) => [key(r), r.tokens]));
+
+    const entries: GrowthEntry[] = [];
+    for (const [k, tokens] of a) {
+        const prev = b.get(k);
+        const [kind, ...rest] = k.split(':');
+        const name = rest.join(':');
+        if (prev === undefined) {
+            entries.push({ name, kind: kind as AssetKind, delta: tokens, status: 'added' });
+        } else if (tokens !== prev) {
+            entries.push({ name, kind: kind as AssetKind, delta: tokens - prev, status: tokens > prev ? 'grew' : 'shrank' });
+        }
+    }
+    for (const [k, tokens] of b) {
+        if (a.has(k)) continue;
+        const [kind, ...rest] = k.split(':');
+        entries.push({ name: rest.join(':'), kind: kind as AssetKind, delta: -tokens, status: 'removed' });
+    }
+
+    const increases = entries.filter((e) => e.delta > 0).sort((x, y) => y.delta - x.delta || x.name.localeCompare(y.name));
+    const decreases = entries.filter((e) => e.delta < 0).sort((x, y) => x.delta - y.delta || x.name.localeCompare(y.name));
+    return { increases, decreases, net_delta: entries.reduce((n, e) => n + e.delta, 0) };
+}
+
+/**
+ * Render an attribution as the lines a refusing gate appends to its message.
+ *
+ * Capped, because a refusal listing 400 assets is as unactionable as one listing
+ * none — and the cap is stated rather than silent, so a reader knows the list is
+ * a head and not the whole story.
+ */
+export function renderAttribution(g: GrowthAttribution, limit = 5): string[] {
+    if (g.increases.length === 0 && g.decreases.length === 0) return [];
+    const out: string[] = [];
+    const sign = (n: number): string => (n >= 0 ? `+${String(n)}` : String(n));
+    out.push(`    net delivered-token change: ${sign(g.net_delta)} tok`);
+    if (g.increases.length > 0) {
+        out.push(`    grew or arrived (top ${String(Math.min(limit, g.increases.length))} of ${String(g.increases.length)}):`);
+        for (const e of g.increases.slice(0, limit)) {
+            out.push(`      ${sign(e.delta).padStart(7)} tok  ${e.name} (${e.kind}, ${e.status})`);
+        }
+    }
+    if (g.decreases.length > 0) {
+        out.push(`    shrank or left (top ${String(Math.min(limit, g.decreases.length))} of ${String(g.decreases.length)}):`);
+        for (const e of g.decreases.slice(0, limit)) {
+            out.push(`      ${sign(e.delta).padStart(7)} tok  ${e.name} (${e.kind}, ${e.status})`);
+        }
+    }
+    return out;
+}

package/src/scripts/_lib/audit_field_provenance.ts

@@ -0,0 +1,54 @@
+/**
+ * Which audit-log fields are OBSERVED and which are producer constants.
+ *
+ * This module exists because a prose sentence was wrong for months and nothing
+ * could tell. `docs/contracts/audit-log-v1.md` described `rules_applied` as
+ * "stable rule ids whose Iron Law fired this phase" — an observation — while
+ * both shipped producers write the literal `['delegation-policy']` on every
+ * line. A consumer following the contract computes a per-rule win rate of 100 %
+ * for one rule and `undefined` for the other 118, and that reads as a finding.
+ *
+ * It was found by the loop rather than by review: mining the real audit stream
+ * with `extract_audit_patterns --min-count 2` mints exactly ONE pattern,
+ * `implement:success:delegation-policy`, at count 914 over 935 lines. A
+ * regularity that strong in a field that varied would be remarkable; in a field
+ * that does not vary it is arithmetic.
+ *
+ * The prose was DELETED rather than softened, and this check replaces it. A
+ * sentence cannot stop a consumer from aggregating over a constant; a function
+ * the consumer must call can, and it goes stale loudly instead of silently
+ * because the producers are named here and a test asserts they still match.
+ *
+ * road-to-experience-loop-broadening step 9.3 — the removal the loop motivated.
+ */
+
+/**
+ * Fields a shipped producer writes as a fixed value, with the value.
+ *
+ * A field listed here is NOT evidence about the run. Adding a row is how a
+ * future producer records the same honesty; removing one requires that the
+ * producer actually compute the field.
+ */
+export const PRODUCER_CONSTANT_FIELDS: ReadonlyMap<string, readonly string[]> = new Map([
+    // Written identically by `orchestration_record.ts` and
+    // `review_skipped_record.ts`. Neither computes it from rules that fired.
+    ['rules_applied', ['delegation-policy']],
+]);
+
+/** True when a per-asset rate over this field would measure the producer. */
+export function isProducerConstantField(field: string): boolean {
+    return PRODUCER_CONSTANT_FIELDS.has(field);
+}
+
+/**
+ * The reason, for a consumer that wants to say why it skipped a column.
+ * `null` when the field is genuinely observed.
+ */
+export function constantFieldReason(field: string): string | null {
+    const v = PRODUCER_CONSTANT_FIELDS.get(field);
+    if (v === undefined) return null;
+    return (
+        `'${field}' is written as the fixed value [${v.map((x) => `'${x}'`).join(', ')}] by every shipped ` +
+        'producer, so any rate computed over it measures the writer rather than the work.'
+    );
+}

package/src/scripts/_lib/auto_dispatch.ts

@@ -156,14 +156,43 @@ const LOOKUP_PATTERNS: Array<{ cls: LookupClass; primitive: LookupPrimitive; re:
  * silently degraded answer; an index-miss at execution time escalates the
  * same way (runtime concern, documented in the classification context).
  */
-export function classifyLookup(taskText: string): LookupRoute {
+export function classifyLookup(
+    taskText: string,
+    opts: { codeGraphEnabled?: boolean | undefined } = {},
+): LookupRoute {
+    // The graph is an OPPORTUNISTIC ACCELERANT, gated on the setting — which is
+    // what `auto-dispatch-classification.md` § Task pattern has always said and
+    // what this function did not do.
+    //
+    // road-to-inbox-harvest-2026-08-f-code-graph-evidence-refresh 2.1 required
+    // deciding which of the two was right and changing the other, not splitting
+    // the difference. The CONTRACT is right, on the only evidence that exists:
+    // the pre-registered benchmark behind `claim:code-graph-retrieval-null`
+    // measured native-graph recall 0.365 against grep's 0.797 on exactly these
+    // graph-shaped questions. Routing to the graph unconditionally routed to the
+    // arm that lost, and no re-measurement has replaced that figure — Phase 3.1
+    // is blocked on inputs this repository does not hold.
+    //
+    // Default FALSE, deliberately, and not because the setting's default is
+    // false: an absent flag means nobody said the index is present and fresh,
+    // and an accelerant taken on an absent index is a miss that escalates —
+    // slower than the grep it replaced. When the flag is on, the class still
+    // routes to `code-graph-query`, so turning it on is the whole change needed
+    // to use the graph.
+    const graphOk = opts.codeGraphEnabled === true;
     for (const p of LOOKUP_PATTERNS) {
         if (p.re.test(taskText)) {
+            const primitive: LookupPrimitive =
+                p.primitive === 'code-graph-query' && !graphOk ? 'fts-or-capped-grep' : p.primitive;
             return {
                 lookup_class: p.cls,
                 route: 'primitive',
-                primitive: p.primitive,
-                reason: `lookup-class ${p.cls} — deterministic primitive, no spawn`,
+                primitive,
+                reason:
+                    primitive === p.primitive
+                        ? `lookup-class ${p.cls} — deterministic primitive, no spawn`
+                        : `lookup-class ${p.cls} — capped grep; the code-graph accelerant is ` +
+                          'gated on hooks.code_graph.enabled and it is not on',
             };
         }
     }

package/src/scripts/_lib/bench_ab_size_claim.ts

@@ -13,6 +13,8 @@
  * change to either has to touch the record and the code together.
  */
 
+import { decidePairedVerdict, floorWarning, MIN_DISCORDANT } from './paired_verdict.js';
+
 /** T1 — median added lines must fall by at least this much. */
 export const T1_MEDIAN_LINES_PCT = -10;
 /** Two-sided significance for every endpoint in the pair. */
@@ -25,7 +27,15 @@ export interface PairedContinuous {
     /** `null` when the baseline median is 0 — no percent change exists. */
     median_delta_pct: number | null;
     median_delta: number;
+    /**
+     * Retained for TRIAGE and reporting. Since PREREG amendment v2 it decides
+     * nothing — see {@link evaluateSizeClaim}.
+     */
     wilcoxon_p: number;
+    /** Non-tied pairs in the direction of interest. Absent on a pre-amendment report. */
+    direction_wins?: number | undefined;
+    /** Non-tied pairs against the direction of interest. Absent on a pre-amendment report. */
+    direction_losses?: number | undefined;
 }
 
 /** A paired binary endpoint (the safety tier). */
@@ -56,6 +66,44 @@ export interface SizeClaimVerdict {
     safety_measured: boolean;
 }
 
+
+
+/** One clause naming the directional evidence, printable in a verdict reason. */
+function describeDirection(v: ReturnType<typeof decidePairedVerdict> | null): string {
+    if (v === null) {
+        return `no direction counts in the report — pre-amendment or unmeasured, so the direction bar is not met`;
+    }
+    if (v.kind === 'underpowered') {
+        return `underpowered: ${String(v.discordant)} non-tied pair(s) below the derived floor of ${String(MIN_DISCORDANT)}`;
+    }
+    const warn = floorWarning(v);
+    return `${String(v.wins)}/${String(v.discordant)} non-tied pairs, one-sided exact p=${v.p.toFixed(4)}` +
+        (warn === null ? '' : ` — ${warn}`);
+}
+
+/**
+ * The directional verdict for one endpoint, or `null` when it cannot be formed.
+ *
+ * `null` means the report carries no direction counts — a pre-amendment report,
+ * or an unmeasured endpoint. The caller treats that as "not significant" rather
+ * than reaching for `wilcoxon_p`, which is the whole point of the amendment.
+ *
+ * The counts are reconstructed into a delta vector of ±1 rather than carrying
+ * raw deltas through the report: the exact sign test needs direction only, and
+ * a council seat noted the raw deltas are preferable for auditability but not
+ * mathematically required. The raw values remain in the trial artifacts.
+ */
+function directionVerdict(e: PairedContinuous): ReturnType<typeof decidePairedVerdict> | null {
+    if (!e.measured) return null;
+    const w = e.direction_wins;
+    const l = e.direction_losses;
+    if (w === undefined || l === undefined) return null;
+    return decidePairedVerdict({
+        deltas: [...Array<number>(w).fill(1), ...Array<number>(l).fill(-1)],
+        alpha: ALPHA,
+    });
+}
+
 /**
  * Evaluate the size claim for one comparison — binding, and structurally unable
  * to report a win on size alone.
@@ -98,9 +146,52 @@ export function evaluateSizeClaim(input: SizeClaimInput): SizeClaimVerdict {
         };
     }
 
-    const cx_rose = cx.measured && cx.median_delta > 0 && cx.wilcoxon_p < ALPHA;
+    // ── PREREG amendment v2, 2026-08-26 — direction decides significance ────
+    //
+    // The significance half of every endpoint below was a Wilcoxon signed-rank
+    // p, which ranks by |difference| and is therefore magnitude-weighted. That
+    // was shown to disagree with the exact test on twelve records up to ten
+    // trials, PERMISSIVE in every one, with the visible symptom inverted: an
+    // artifact winning every trial still failed, because a few large
+    // opposite-direction deltas outweighed a clean sweep of small ones.
+    //
+    // TWO PROPOSITIONS, KEPT SEPARATE — this is the refinement both council
+    // seats independently required (2026-08-26, 2/2) and it is the half that
+    // makes the amendment safe. A sign test answers "did this help more often
+    // than it hurt" and says NOTHING about how much. Replacing Wilcoxon with it
+    // outright would let a clean sweep of negligible improvements claim a SIZE
+    // win. So:
+    //   · directional reliability → exact one-sided sign test over non-tied pairs
+    //   · practical magnitude     → the pre-registered T1_MEDIAN_LINES_PCT bar,
+    //                               unchanged and still independently binding
+    // Both must hold. Dropping either is a different claim and needs its own
+    // amendment.
+    //
+    // A report predating the amendment carries no direction counts. It is
+    // treated as UNMEASURED for the significance half rather than falling back
+    // to `wilcoxon_p`, because a silent fallback to the defective test is
+    // exactly what this amendment removes.
+    const sizeDir = directionVerdict(size);
+    const cxDir = directionVerdict(cx);
+    // ASYMMETRY, deliberate and the conservative direction of it. A PASS needs
+    // the direction bar MET; a REFUSAL fires on EITHER signal. Applying the
+    // strict reading to both would make the anti-golfing refusal disappear on
+    // any report without direction counts — a missing input silently rescuing
+    // an arm is the failure mode a refusal exists to prevent, and it is the
+    // opposite of what the amendment is for. So the refusal keeps the legacy
+    // Wilcoxon signal as a second trigger; the claim does not.
+    const cx_rose =
+        cx.measured &&
+        cx.median_delta > 0 &&
+        (cxDir === null ? cx.wilcoxon_p < ALPHA : cxDir.kind === 'regression');
+    // `regression`, NOT `pass`, and the distinction cost a test run to find.
+    // `direction_wins` counts the endpoint's IMPROVEMENT direction — a negative
+    // delta — for every continuous endpoint, so on complexity a `pass` means
+    // complexity FELL. What `cx_rose` needs is the opposite tail, which is
+    // exactly what `regression` names. Writing `pass` here reads correctly in
+    // English and inverts the anti-golfing guard.
     const pct = size.measured ? size.median_delta_pct : null;
-    const lines_fell = pct !== null && pct <= T1_MEDIAN_LINES_PCT && size.wilcoxon_p < ALPHA;
+    const lines_fell = pct !== null && pct <= T1_MEDIAN_LINES_PCT && sizeDir?.kind === 'pass';
 
     // (2b) Golfing is refused as soon as T2 shows it, and does NOT wait for T4.
     //
@@ -161,8 +252,11 @@ export function evaluateSizeClaim(input: SizeClaimInput): SizeClaimVerdict {
         ...base,
         verdict: lines_fell ? 'PASS' : 'NO-SIZE-WIN',
         reason: lines_fell
-            ? `median added lines ${pct}% at p=${size.wilcoxon_p} with no significant complexity rise and no safety regression`
-            : `T1 not met (median added lines ${pct}% at p=${size.wilcoxon_p}; bar is <= ${T1_MEDIAN_LINES_PCT}% at p<${ALPHA})`,
+            ? `median added lines ${pct}% (magnitude bar) AND ${describeDirection(sizeDir)} (direction bar) ` +
+              'with no significant complexity rise and no safety regression'
+            : `T1 not met (median added lines ${pct}%, bar <= ${T1_MEDIAN_LINES_PCT}%; ` +
+              `direction: ${describeDirection(sizeDir)}). Wilcoxon p=${size.wilcoxon_p} is reported for ` +
+              'triage and decides nothing.',
         lines_fell,
         size_measured: true,
         complexity_measured: true,