@event4u/agent-config 8.10.0 → 8.11.0

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);
+});

package/src/scripts/build_discovery_manifest.ts

@@ -419,6 +419,12 @@ function* _iter_artefacts(): Generator<[string, string]> {
     // `_classify` subagent branch derives the manifest payload (default-off,
     // packs:[]) — static projection only, never runtime-dispatched.
     for (const p of _collect('subagents', '*.md')) {
+        // `_`-prefixed files are injected partials (e.g. _prompt-defense.md),
+        // not projectable agents — never discovery artefacts. Mirrors the
+        // same filter in condense.generate_claude_subagents.
+        if (path.basename(p).startsWith('_')) {
+            continue;
+        }
         yield [p, 'subagent'];
     }
 }

package/src/scripts/build_proof.ts

@@ -27,6 +27,7 @@ import { REPO, LEDGER_REL, load_ledger, pointer_unresolved } from './check_claim
 import { collectSkillGaps } from './check_skill_gaps.js';
 import { loadRows as loadComparisonRows } from './check_comparison.js';
 import { computeStatus as domainSoundnessStatus } from './domain_soundness_status.js';
+import { computeCoverage } from './skill_eval_coverage.js';
 
 const _FILE = fileURLToPath(import.meta.url);
 const OUT_REL = 'docs/proof.md';
@@ -108,16 +109,27 @@ function render(): string {
         L.push('Benchmark results are published under `docs/` including measured nulls.');
     }
     L.push('');
+    const cov = computeCoverage();
+    const prio = cov.tiers.priority;
+    const other = cov.tiers.other;
+    const prioLine =
+        prio.covered === prio.total
+            ? `\`rich\` + routers) are **fully covered (${prio.covered} of ${prio.total})**, the long tail`
+            : `\`rich\` + routers, **${prio.covered} of ${prio.total}**) are partially covered; the long tail`;
     L.push('**Behavioural-eval coverage — the honest baseline.** Skill *quality* is only');
-    L.push('as good as its measurement. Today **2 of 264** skills carry a behavioural');
-    L.push('`evals.json`, and the highest-traffic / highest-cost tiers (default-surface +');
-    L.push('`rich` + routers, **0 of 35**) are not yet covered. We publish that gap rather');
-    L.push('than imply "264 evaluated skills": coverage is measured per tier');
-    L.push('(`./scripts-run src/scripts/skill_eval_coverage`) and **CI-ratcheted so it can');
-    L.push('only rise** — a merged change can never lower it. Authoring the priority-tier');
-    L.push('evals is gated on per-case human ratification (a generated assertion that');
-    L.push('checks the wrong property is worse than none), so the number grows');
-    L.push('deliberately, not overnight.');
+    L.push(`as good as its measurement. Today **${cov.overall.covered} of ${cov.overall.total}** skills carry a behavioural`);
+    L.push('`evals.json`; the highest-traffic / highest-cost tiers (default-surface +');
+    L.push(prioLine);
+    L.push(`(${other.covered} of ${other.total}) is not. We publish that gap rather than imply`);
+    L.push(`"${cov.overall.total} evaluated skills": coverage is measured per tier`);
+    L.push('(`./scripts-run src/scripts/skill_eval_coverage`), **CI-ratcheted so it can');
+    L.push('only rise**, and the priority tiers carry a hard **tier floor**: every');
+    L.push('rich / default-surface / router skill MUST have a behavioural eval or an');
+    L.push('explicit exemption-with-reason in `internal/evals/tier-floor-exemptions.json`');
+    L.push('— no silent exemptions (the bright line deliberately replaces a');
+    L.push('weighted-coverage score). Authoring long-tail evals is gated on per-case');
+    L.push('human ratification (a generated assertion that checks the wrong property is');
+    L.push('worse than none), so the number grows deliberately, not overnight.');
     L.push('');
     const ds = domainSoundnessStatus();
     L.push('**Non-coding domain soundness — scoped, not proven.** The `finance` /');

package/src/scripts/check_claims.ts

@@ -42,6 +42,13 @@ const SURFACE_ROOTS = ['README.md', 'docs'];
 const CLAIM_MARKER = /<!--\s*claim:([A-Za-z0-9._-]+)\s*-->/g;
 const URL_DATED = /^https?:\/\/\S+\(\d{4}-\d{2}-\d{2}\)\s*$/;
 
+/** Witness sweep (P1.2) — marketing-class surfaces where a bare number must
+ *  not appear as a capability claim. docs/proof.md and docs/comparison.yaml
+ *  are structurally witnessed (pointer columns + their own linters). */
+const WITNESS_SURFACES = ['README.md', 'CAPABILITIES.yaml'];
+/** A percentage or multiplier reading as a measured capability figure. */
+const QUANTIFIED_CLAIM = /\b\d+(?:\.\d+)?\s*(?:%|[x×](?![A-Za-z0-9]))/;
+
 class ExitCode extends Error {
     code: number;
     constructor(code: number) {
@@ -224,6 +231,39 @@ function main(argv: string[] = process.argv.slice(2)): number {
         if (un) findings.push({ id: entry.id, file: LEDGER_REL, reason: `backed entry has dangling evidence — ${un}` });
     }
 
+    // 3. Witness sweep (road-to-opt-subagent-harvest P1.2): a QUANTIFIED
+    //    capability claim on a marketing-class surface must be witnessed — a
+    //    `<!-- claim:ID -->` marker on the same line, or an explicit
+    //    `unverified` annotation. Unmarkered numbers are exactly how an
+    //    "84.8%"-style figure spreads across surfaces with no methodology
+    //    (the anti-lesson this check encodes). Fenced code blocks are skipped.
+    for (const rel of WITNESS_SURFACES) {
+        const abs = path.join(REPO, rel);
+        let text: string;
+        try {
+            text = fs.readFileSync(abs, 'utf-8');
+        } catch {
+            continue;
+        }
+        let inFence = false;
+        const lines = text.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] as string;
+            if (/^\s*(```|~~~)/.test(line)) {
+                inFence = !inFence;
+                continue;
+            }
+            if (inFence) continue;
+            if (!QUANTIFIED_CLAIM.test(line)) continue;
+            if (/<!--\s*claim:/.test(line) || /unverified/i.test(line)) continue;
+            findings.push({
+                id: '(unmarkered)',
+                file: `${rel}:${i + 1}`,
+                reason: `quantified claim without a claim marker or 'unverified' annotation — ${line.trim().slice(0, 70)}`,
+            });
+        }
+    }
+
     if (findings.length > 0) {
         process.stderr.write(`❌  check_claims: ${findings.length} unbacked/dangling claim(s):\n`);
         for (const f of findings) {

package/src/scripts/check_rule_invariants.ts

@@ -64,7 +64,12 @@ function loadEntries(root: string): InvariantEntry[] {
     if (!Array.isArray(parsed)) {
         throw new Error(`${INVARIANTS_JSON}: expected a top-level array`);
     }
-    for (const entry of parsed as InvariantEntry[]) {
+    // A leading `{"_meta": ...}` element carries the change-process pointer
+    // (JSON has no comments); it is not an invariant entry.
+    const entries = (parsed as Array<InvariantEntry | { _meta: unknown }>).filter(
+        (e): e is InvariantEntry => !('_meta' in e),
+    );
+    for (const entry of entries) {
         if (
             typeof entry.rule !== 'string' ||
             typeof entry.file !== 'string' ||
@@ -77,7 +82,7 @@ function loadEntries(root: string): InvariantEntry[] {
             );
         }
     }
-    return parsed as InvariantEntry[];
+    return entries;
 }
 
 /** Check one entry against pre-normalised file contents. */
@@ -144,7 +149,9 @@ function formatText(misses: Miss[], invariantCount: number): string {
     lines.push(
         '\nA kernel rule lost a load-bearing clause — likely a merge or condensation ' +
             'dropped it silently (see the #840/#844 incident in this file header). ' +
-            'Restore the clause or deliberately update tests/golden/invariants.json.',
+            'Restore the clause, or reword it via the documented change process: ' +
+            'docs/contracts/kernel-membership.md § 10 — Changing a protected invariant ' +
+            '(never "update the gate green").',
     );
     return lines.join('\n');
 }

package/src/scripts/condense.ts

@@ -1634,10 +1634,20 @@ export function generate_claude_subagents(): number {
     }
     _mkdirp(MODULE_STATE.CLAUDE_AGENTS_DIR);
 
-    const sources = _rglobSorted(MODULE_STATE.SUBAGENTS_SOURCE, '*.md').filter((p) => _isFile(p));
+    const sources = _rglobSorted(MODULE_STATE.SUBAGENTS_SOURCE, '*.md').filter(
+        (p) => _isFile(p) && !path.basename(p).startsWith('_'),
+    );
     const current = new Set<string>();
     let count = 0;
 
+    // Prompt-defense preamble partial (road-to-opt-subagent-harvest P1.1):
+    // `_`-prefixed files in src/subagents/ are partials, never agents. The
+    // preamble is injected at the top of every projected body so the whole
+    // fleet carries a uniform injection-defense baseline — each dispatched
+    // subagent is an untrusted-content ingestion point.
+    const defensePath = path.join(MODULE_STATE.SUBAGENTS_SOURCE, '_prompt-defense.md');
+    const defense = _isFile(defensePath) ? _readText(defensePath).trim() : '';
+
     for (const src of sources) {
         const stem = path.basename(src, '.md');
         const text = _readText(src);
@@ -1661,6 +1671,10 @@ export function generate_claude_subagents(): number {
         const tier = typeof fm['model_tier'] === 'string' ? (fm['model_tier'] as string) : 'inherit';
         const model = tier === 'inherit' ? 'inherit' : (_TIER_TO_CLAUDE_MODEL[tier] ?? 'inherit');
 
+        const guardedBody =
+            defense !== '' && !body.includes('prompt-defense-preamble')
+                ? `\n${defense}\n${body}`
+                : body;
         const out =
             '---\n' +
             `name: ${name}\n` +
@@ -1668,7 +1682,7 @@ export function generate_claude_subagents(): number {
             `tools: ${tools}\n` +
             `model: ${model}\n` +
             '---\n' +
-            body;
+            guardedBody;
 
         const target = path.join(MODULE_STATE.CLAUDE_AGENTS_DIR, `${name}.md`);
         _writeText(target, out);

package/src/scripts/consumer_matrix.ts

@@ -52,6 +52,8 @@ interface LegResult {
     ok: boolean;
     detail: string;
     durationMs: number;
+    /** fn ran to completion (a declared skip or an after-failure skip is NOT executed). */
+    executed: boolean;
 }
 
 function log(msg: string): void {
@@ -313,13 +315,20 @@ async function main(): Promise<number> {
         if (only && !only.includes(leg.name)) continue;
         // Legs after a hard dependency failure cannot run meaningfully.
         if (failed) {
-            ctx.results.push({ leg: leg.name, ok: false, detail: 'skipped (earlier leg failed)', durationMs: 0 });
+            ctx.results.push({
+                leg: leg.name,
+                ok: false,
+                detail: 'skipped (earlier leg failed)',
+                durationMs: 0,
+                executed: false,
+            });
             continue;
         }
         const t0 = Date.now();
         try {
             const detail = await leg.fn(ctx);
-            ctx.results.push({ leg: leg.name, ok: true, detail, durationMs: Date.now() - t0 });
+            const executed = !detail.startsWith('skipped');
+            ctx.results.push({ leg: leg.name, ok: true, detail, durationMs: Date.now() - t0, executed });
             log(`  ✅  ${leg.name} — ${detail}`);
         } catch (err) {
             ctx.results.push({
@@ -327,12 +336,42 @@ async function main(): Promise<number> {
                 ok: false,
                 detail: (err as Error).message,
                 durationMs: Date.now() - t0,
+                executed: true,
             });
             log(`  ❌  ${leg.name} — ${(err as Error).message}`);
             failed = true;
         }
     }
 
+    // Leg-completeness gate (road-to-fable-feedback-5 Phase 6a): a full run
+    // (no --only) must have EXECUTED every expected leg — a silently-skipped
+    // leg can no longer ride a green workflow. The only declared skip is
+    // `upgrade` under an explicit --skip-registry flag.
+    if (!only && !failed) {
+        const declaredSkips = new Set(ctx.skipRegistry ? ['upgrade'] : []);
+        const missing = LEGS.filter((l) => {
+            const r = ctx.results.find((x) => x.leg === l.name);
+            return r === undefined || (!r.executed && !declaredSkips.has(l.name));
+        }).map((l) => l.name);
+        if (missing.length > 0) {
+            log(`❌  leg-completeness gate: expected leg(s) did not execute: ${missing.join(', ')}`);
+            failed = true;
+        }
+    }
+
+    const manifestPath = getOpt('--manifest');
+    if (manifestPath) {
+        const manifest = {
+            ok: !failed,
+            node: process.version,
+            skipRegistry: ctx.skipRegistry,
+            expected: LEGS.map((l) => l.name),
+            results: ctx.results,
+        };
+        fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+        log(`leg manifest written: ${manifestPath}`);
+    }
+
     if (argv.includes('--json')) {
         process.stdout.write(`${JSON.stringify({ ok: !failed, results: ctx.results }, null, 2)}\n`);
     }