@event4u/agent-config 8.10.0 → 8.12.0

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';
@@ -104,20 +105,40 @@ function render(): string {
         L.push(`Benchmark results — **including the runs where the package changed nothing** —`);
         L.push(`live in [\`${BENCH_REL}\`](benchmark.md). We do not delete a measured null to`);
         L.push('make a number look better; the null is the evidence of honesty.');
+        L.push('');
+        L.push('The freshest example: the **persona-placebo benchmark** <!-- claim:persona-identity-placebo-null -->');
+        L.push('(2026-07-12, 3 arms × 2 providers, blind rubric judge, pre-registered');
+        L.push('hypotheses) measured whether famous-figure persona framing improves decision');
+        L.push('answers over the bare method text it wraps. It does not (Δ=0.17, p=0.607) —');
+        L.push('while provider diversity moved judged quality ~15× more than persona identity.');
+        L.push('The measured null closed a planned feature (persona panel-mode) instead of');
+        L.push('shipping theater; the full per-cell data is committed at');
+        L.push('`internal/bench/reports/persona-placebo.json`.');
     } else {
         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_artefact_count_messaging.ts

@@ -113,6 +113,49 @@ export function scan_text(
     return { findings, seen };
 }
 
+/** Structured-surface totals — generated files whose counts are YAML fields,
+ * not prose, so the KIND_PATTERNS prose scan cannot see them. CAPABILITIES.yaml
+ * proved this gap: it drifted to 268/177 while every prose surface said
+ * 271/178, because only its own `--check` guarded it and a stale commit can
+ * land through parallel merges. This scan makes the messaging gate a second,
+ * independent net over the same canonical counts. */
+export const STRUCTURED_SURFACES: ReadonlyArray<{
+    file: string;
+    fields: ReadonlyArray<[kind: string, pattern: RegExp]>;
+}> = [
+    {
+        file: 'CAPABILITIES.yaml',
+        fields: [
+            ['skills', /^\s*skills_total:\s*(\d+)\s*$/m],
+            ['commands', /^\s*commands_total:\s*(\d+)\s*$/m],
+        ],
+    },
+];
+
+export function scan_structured(
+    rel: string,
+    text: string,
+    fields: ReadonlyArray<[string, RegExp]>,
+    expected: Record<string, number>,
+): { findings: Finding[]; seen: Record<string, Set<number>> } {
+    const findings: Finding[] = [];
+    const seen: Record<string, Set<number>> = {};
+    for (const [kind, pattern] of fields) {
+        const m = text.match(pattern);
+        if (m === null) {
+            continue; // absent field is the generator's own --check's problem
+        }
+        const found = Number.parseInt(m[1]!, 10);
+        (seen[kind] ??= new Set()).add(found);
+        const exp = expected[kind]!;
+        if (found !== exp) {
+            const line = text.slice(0, m.index ?? 0).split('\n').length;
+            findings.push({ file: rel, line, kind, found, expected: exp, approx: false });
+        }
+    }
+    return { findings, seen };
+}
+
 export function main(argv: readonly string[] = process.argv.slice(2)): number {
     const QUIET = argv.includes('--quiet');
     const expected: Record<string, number> = {};
@@ -140,6 +183,19 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
         }
     }
 
+    for (const { file, fields } of STRUCTURED_SURFACES) {
+        const p = path.join(ROOT, file);
+        if (!fs.existsSync(p)) {
+            process.stderr.write(`  ⚠️  surface missing (skipped): ${file}\n`);
+            continue;
+        }
+        const { findings, seen } = scan_structured(file, fs.readFileSync(p, 'utf-8'), fields, expected);
+        allFindings.push(...findings);
+        for (const [kind, nums] of Object.entries(seen)) {
+            for (const n of nums) (global_seen[kind] ??= new Set()).add(n);
+        }
+    }
+
     // Internal-inconsistency check — the regression case this gate exists
     // for: multiple DIFFERENT numbers for one kind across the surfaces.
     const inconsistent: string[] = [];

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_knowledge_cards.ts

@@ -105,13 +105,17 @@ function _frontmatter_get(text: string, ...keys: string[]): string {
 // ---------------------------------------------------------------------------
 
 /**
- * Global-store-only checks (ADR-100): tier validity, provenance footer,
- * and a redaction-clean assertion (the secret/PII patterns must have been
- * halted/cleaned before the card was written — never present in a global card).
+ * Global-store-only checks (ADR-100 + Phase 1 sensitivity axis,
+ * road-to-feedback-8.11 / successor note to ADR-119): tier validity,
+ * sensitivity validity, provenance footer (incl. the promotion audit-trail
+ * fields), and a redaction-clean assertion (the secret/PII patterns must
+ * have been halted/cleaned before the card was written — never present in a
+ * global card).
  */
 function _check_global_card(rel: string, text: string, fm: Record<string, string>): string[] {
     const errors: string[] = [];
     const valid_tiers = _kg !== null ? _kg.TIERS : ['public', 'vendor', 'proprietary'];
+    const valid_sensitivities = _kg !== null ? _kg.SENSITIVITIES : ['prohibited', 'project', 'shareable'];
 
     // G1 — tier present and valid
     const tier = (fm['tier'] ?? '').trim();
@@ -121,7 +125,27 @@ function _check_global_card(rel: string, text: string, fm: Record<string, string
         errors.push(`${rel}:0 — G1: tier '${tier}' not in ${_pyReprList(_sorted(valid_tiers))}`);
     }
 
-    // G2 — provenance footer present with all fields
+    // G4 — sensitivity present and valid
+    const sensitivity = (fm['sensitivity'] ?? '').trim();
+    if (!sensitivity) {
+        errors.push(`${rel}:0 — G4: global card missing 'sensitivity' in frontmatter`);
+    } else if (!valid_sensitivities.includes(sensitivity)) {
+        errors.push(
+            `${rel}:0 — G4: sensitivity '${sensitivity}' not in ${_pyReprList(_sorted(valid_sensitivities))}`,
+        );
+    }
+
+    // G6 — a `prohibited` card must never be in the global store at all: it
+    // contains redaction-class content and should never have left the
+    // project. Hard error regardless of anything else on the card.
+    if (sensitivity === 'prohibited') {
+        errors.push(
+            `${rel}:0 — G6: sensitivity 'prohibited' must never be in the global store ` +
+                '(redaction-class content — this card should never have been promoted)',
+        );
+    }
+
+    // G2 + G5 — provenance footer present with all promotion audit-trail fields
     if (_kg !== null) {
         const prov = _kg.parse_provenance_footer(text);
         if (!_pyTruthyObj(prov)) {
@@ -132,6 +156,11 @@ function _check_global_card(rel: string, text: string, fm: Record<string, string
                     errors.push(`${rel}:0 — G2: provenance footer missing '${field}'`);
                 }
             }
+            for (const field of ['source_repo', 'owner', 'review_after', 'promotion_reason']) {
+                if (!prov[field]) {
+                    errors.push(`${rel}:0 — G5: provenance footer missing '${field}'`);
+                }
+            }
         }
     }
 

package/src/scripts/check_portability.ts

@@ -468,6 +468,7 @@ const _TASK_DETECTOR_SKIP = [
     // CI-shaped literals; its mechanics doc and the execution loop +
     // authoring skill enumerate the same literals to detect them.
     'rules/roadmap-ci-steps-policy.md',
+    'contexts/execution/roadmap-ci-steps-mechanics.md',
     'contexts/execution/roadmap-process-loop.md',
     'skills/roadmap-writing/SKILL.md',
 ];

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