@event4u/agent-config 8.10.0 → 8.12.0

package/src/scripts/lint_knowledge_scale.ts

@@ -166,6 +166,36 @@ export function runChecks(root: string): Warning[] {
         });
     }
 
+    // 6. Contested cards — surface knowledge cards flagged `contested: true`
+    //    (set when `check_memory_contradiction.ts` fires) so a weak / disputed
+    //    claim stays visibly weak across sessions instead of silently hardening.
+    const cardsDir = path.join(root, 'agents', 'knowledge');
+    const contested = listFiles(cardsDir, ['.md'])
+        .filter((f) => {
+            const base = path.basename(f).toLowerCase();
+            return base !== 'readme.md' && base !== 'index.md';
+        })
+        .filter((f) => {
+            let text: string;
+            try {
+                text = fs.readFileSync(f, 'utf-8');
+            } catch {
+                return false;
+            }
+            // frontmatter-scoped: `contested: true` on its own line near the top.
+            return /^\s*contested:\s*true\s*$/m.test(text.slice(0, 2000));
+        })
+        .map((f) => path.basename(f));
+    if (contested.length > 0) {
+        warnings.push({
+            rule: 'contested-cards',
+            metric: `${contested.length}/0`,
+            message:
+                `${contested.length} knowledge card(s) carry \`contested: true\`: ${contested.join(', ')}. ` +
+                'Resolution path: reconcile each against its `contradictions: [id]` list (human-judged) — a contested claim must not be cited as settled until resolved.',
+        });
+    }
+
     // 5. Hot-context budget.
     const hotContext = path.join(root, 'agents', 'runtime', 'state', 'hot-context.md');
     let hotText = '';

package/src/scripts/lint_originality_shingles.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env tsx
+/**
+ * lint_originality_shingles — mechanical re-skin detector for the artifact
+ * corpus (road-to-opt-subagent-harvest P1.3).
+ *
+ * Compares every pair of skills / personas / subagents by entity-neutralized
+ * 8-word shingle overlap. Two artifacts that differ only in the named
+ * framework, product, or persona ("re-skins") share almost all shingles once
+ * entities are masked — exactly the near-duplicate class a human review
+ * misses at 200+ files. Slots beside `persona-governance` / `skill-quality`.
+ *
+ * Sibling of `lint_skill_originality` (ADR-096), NOT a replacement: that
+ * gate runs bag-of-words Jaccard over SKILLS with pack-domain severity;
+ * this one masks entities and compares 8-word PHRASES across skills +
+ * personas + subagents — the re-skin that only swaps "Laravel" for
+ * "Django" scores LOW on plain token-Jaccard (different entity tokens)
+ * and HIGH here. Run both.
+ *
+ * Modes:
+ *   default             report-only — prints the top overlapping pairs,
+ *                       always exits 0 (first-run calibration mode).
+ *   --threshold <pct>   exits 1 when any pair's overlap (Jaccard, %) is
+ *                       >= pct and the pair is not allowlisted below.
+ *   --top <n>           rows to print (default 15).
+ *   --quiet             suppress the report (threshold mode still fails).
+ *
+ * Known-legitimate pairs (shared scaffolding, sibling carve-outs) are
+ * allowlisted inline with reasons — same >20-entries policy as every other
+ * allowlist in this repo.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const _HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO = path.resolve(_HERE, '..', '..');
+
+const SHINGLE_LEN = 8;
+
+/** Entity mask — named stacks/products/personas collapse to one token so a
+ *  re-skin that only swaps the entity still matches. Lowercase input. */
+const ENTITY_RE = new RegExp(
+    '\\b(laravel|symfony|django|rails|react|vue|angular|nextjs|next\\.js|nuxt|' +
+        'nestjs|express|fastify|flask|fastapi|spring|eloquent|doctrine|prisma|' +
+        'pest|phpunit|jest|vitest|pytest|phpstan|rector|ecs|prettier|eslint|' +
+        'mypy|tsc|php|python|typescript|javascript|node|go|rust|ruby|java|' +
+        'tailwind|blade|livewire|flux|jira|sentry|grafana|terraform|terragrunt|' +
+        'traefik|docker|aws|stripe|openai|anthropic|claude|gemini|gpt)\\b',
+    'g',
+);
+
+interface Doc {
+    id: string;
+    shingles: Set<string>;
+}
+
+interface AllowPair {
+    a: string;
+    b: string;
+    reason: string;
+}
+
+/** Sibling artifacts that legitimately share scaffolding. Keep < 20. */
+const ALLOWLIST: AllowPair[] = [
+    // Populated from calibration runs; empty on first ship — the default
+    // mode is report-only, so no entry is needed until a threshold is armed.
+];
+
+function _normalize(body: string): string[] {
+    // strip fenced code, frontmatter, markdown syntax; mask entities.
+    let text = body.replace(/^---\n[\s\S]*?\n---\n/, '');
+    text = text.replace(/```[\s\S]*?```/g, ' ');
+    text = text.toLowerCase();
+    text = text.replace(ENTITY_RE, '§entity§');
+    text = text.replace(/[^a-z0-9§]+/g, ' ');
+    return text.split(' ').filter((w) => w.length > 0);
+}
+
+function _shingles(words: string[]): Set<string> {
+    const out = new Set<string>();
+    for (let i = 0; i + SHINGLE_LEN <= words.length; i++) {
+        out.add(words.slice(i, i + SHINGLE_LEN).join(' '));
+    }
+    return out;
+}
+
+function _collect(): Doc[] {
+    const docs: Doc[] = [];
+    const push = (id: string, file: string): void => {
+        let body: string;
+        try {
+            body = fs.readFileSync(file, 'utf-8');
+        } catch {
+            return;
+        }
+        const sh = _shingles(_normalize(body));
+        if (sh.size >= 20) {
+            docs.push({ id, shingles: sh });
+        }
+    };
+    const skillsDir = path.join(REPO, 'src', 'skills');
+    for (const d of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+        if (d.isDirectory()) {
+            push(`skill:${d.name}`, path.join(skillsDir, d.name, 'SKILL.md'));
+        }
+    }
+    const personasDir = path.join(REPO, 'src', 'personas');
+    if (fs.existsSync(personasDir)) {
+        const walk = (dir: string, prefix: string): void => {
+            for (const d of fs.readdirSync(dir, { withFileTypes: true })) {
+                const full = path.join(dir, d.name);
+                if (d.isDirectory() && !d.name.startsWith('_')) {
+                    walk(full, prefix);
+                } else if (d.isFile() && d.name.endsWith('.md') && d.name !== 'README.md') {
+                    push(`persona:${path.basename(d.name, '.md')}`, full);
+                }
+            }
+        };
+        walk(personasDir, 'persona');
+    }
+    const subagentsDir = path.join(REPO, 'src', 'subagents');
+    if (fs.existsSync(subagentsDir)) {
+        for (const f of fs.readdirSync(subagentsDir)) {
+            if (f.endsWith('.md') && !f.startsWith('_')) {
+                push(`subagent:${path.basename(f, '.md')}`, path.join(subagentsDir, f));
+            }
+        }
+    }
+    return docs;
+}
+
+function _jaccardPct(a: Set<string>, b: Set<string>): number {
+    const [small, large] = a.size <= b.size ? [a, b] : [b, a];
+    let inter = 0;
+    for (const s of small) {
+        if (large.has(s)) inter++;
+    }
+    const union = a.size + b.size - inter;
+    return union === 0 ? 0 : (100 * inter) / union;
+}
+
+function _allowlisted(a: string, b: string): boolean {
+    return ALLOWLIST.some(
+        (p) => (p.a === a && p.b === b) || (p.a === b && p.b === a),
+    );
+}
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+    let threshold: number | null = null;
+    let top = 15;
+    let quiet = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i] as string;
+        if (arg === '--threshold') threshold = Number(argv[++i]);
+        else if (arg === '--top') top = Number(argv[++i]);
+        else if (arg === '--quiet') quiet = true;
+    }
+
+    const docs = _collect();
+    const pairs: Array<{ a: string; b: string; pct: number }> = [];
+    for (let i = 0; i < docs.length; i++) {
+        for (let j = i + 1; j < docs.length; j++) {
+            const pct = _jaccardPct((docs[i] as Doc).shingles, (docs[j] as Doc).shingles);
+            if (pct > 0.5) {
+                pairs.push({ a: (docs[i] as Doc).id, b: (docs[j] as Doc).id, pct });
+            }
+        }
+    }
+    pairs.sort((x, y) => y.pct - x.pct);
+
+    if (!quiet) {
+        process.stdout.write(
+            `originality-shingles: ${docs.length} docs · ${SHINGLE_LEN}-word entity-masked shingles\n`,
+        );
+        for (const p of pairs.slice(0, top)) {
+            process.stdout.write(`  ${p.pct.toFixed(1).padStart(5)}%  ${p.a}  ↔  ${p.b}\n`);
+        }
+        if (pairs.length === 0) {
+            process.stdout.write('  no pair above 0.5% overlap\n');
+        }
+    }
+
+    if (threshold !== null && Number.isFinite(threshold)) {
+        const offenders = pairs.filter((p) => p.pct >= (threshold as number) && !_allowlisted(p.a, p.b));
+        if (offenders.length > 0) {
+            process.stderr.write(
+                `❌  originality-shingles: ${offenders.length} pair(s) at or above ${threshold}% overlap:\n`,
+            );
+            for (const p of offenders.slice(0, top)) {
+                process.stderr.write(`    ${p.pct.toFixed(1)}%  ${p.a} ↔ ${p.b}\n`);
+            }
+            return 1;
+        }
+    }
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    const a = process.argv[1];
+    if (!a) return false;
+    if (pathToFileURL(path.resolve(a)).href === import.meta.url) return true;
+    try {
+        return fs.realpathSync(a) === fs.realpathSync(fileURLToPath(import.meta.url));
+    } catch {
+        return false;
+    }
+}
+if (_isCliEntry()) {
+    process.exit(main());
+}

package/src/scripts/orchestration_record.ts

@@ -112,6 +112,7 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         tier_chosen: str(flags, 'tier-chosen') as TierChosen | undefined,
         tier_source: str(flags, 'tier-source') as TierSource | undefined,
         task_class: str(flags, 'task-class'),
+        dispatch_mode: str(flags, 'dispatch-mode') as never,
         task_size_estimate: int(flags, 'task-size-estimate'),
         wall_clock_ms: int(flags, 'wall-clock-ms'),
         dispatch_tokens: int(flags, 'dispatch-tokens'),

package/src/scripts/schemas/agent-settings.schema.json

@@ -84,6 +84,17 @@
         }
       }
     },
+    "code_style": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "docblocks": {
+          "type": "string",
+          "enum": ["minimal", "full"],
+          "description": "Consumed by the code-comment-discipline rule. minimal (default) = no signature-mirroring docblocks; docblocks only for machine-relevant precision (generics, array shapes) or genuine why-context. full = exported public library surface may carry one-line summary docblocks; the redundancy ban still holds."
+        }
+      }
+    },
     "tokens": {
       "type": "object",
       "additionalProperties": true,

package/src/scripts/self_review_gate.ts

@@ -21,7 +21,7 @@
  * the `check_quality_regression.gateVerdict` pattern.
  */
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { appendFileSync, existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -244,27 +244,53 @@ export function main(argv: string[]): 0 | 2 {
 
     const key = resolveKey();
     if (!key) {
+        // Explicit NEUTRAL state — never a bare green that reads as "reviewed".
         process.stdout.write(
-            '::notice::self-review-gate skipped — set the ANTHROPIC_API_KEY repo secret to enable the live dogfooded review.\n',
+            '::warning::self-review-gate NEUTRAL — no ANTHROPIC_API_KEY configured, NOTHING was reviewed. ' +
+                'Set the repo secret to enable the live dogfooded review.\n',
         );
+        const summary = process.env.GITHUB_STEP_SUMMARY;
+        if (summary) {
+            appendFileSync(
+                summary,
+                '### Self-review gate: NEUTRAL\n\nNo `ANTHROPIC_API_KEY` secret — nothing was reviewed. This is not a pass.\n',
+            );
+        }
         return 0;
     }
 
-    const client = new AnthropicClient({ api_key: key });
-    const resp = client.ask(buildSystemPrompt(), diffText(baseRef, plan.files), 4096);
-    if (resp.error) {
-        process.stdout.write(`::warning::self-review-gate — model call failed: ${resp.error}\n`);
-        return 0; // advisory: a transport failure never blocks the merge
-    }
-    const findings = parseFindings(resp.text);
-    const body = renderReview(findings, enforce);
-    postReview(body);
+    // Belt-and-suspenders: the WHOLE live path is wrapped so that ANYTHING going
+    // wrong — no API credit / balance (HTTP 402), rate-limit (429), network error,
+    // a client-ctor throw, a parse failure — resolves to a NEUTRAL exit 0, never a
+    // red CI. A missing key or no-credit must never become a merge blocker; the
+    // gate is advisory by design. (Only an --enforce run with real blocking
+    // findings returns 2 — an error is not a finding.)
+    try {
+        const client = new AnthropicClient({ api_key: key });
+        const resp = client.ask(buildSystemPrompt(), diffText(baseRef, plan.files), 4096);
+        if (resp.error) {
+            process.stdout.write(
+                `::warning::self-review-gate NEUTRAL — model call did not complete (${resp.error}); ` +
+                    'nothing was reviewed, not a blocker.\n',
+            );
+            return 0; // no credit / transport / API error → never blocks the merge
+        }
+        const findings = parseFindings(resp.text);
+        const body = renderReview(findings, enforce);
+        postReview(body);
 
-    const code = gateVerdict(findings, { enforce });
-    if (code === 2) {
-        process.stdout.write('::error::self-review-gate — merge-blocking findings under enforce mode.\n');
+        const code = gateVerdict(findings, { enforce });
+        if (code === 2) {
+            process.stdout.write('::error::self-review-gate — merge-blocking findings under enforce mode.\n');
+        }
+        return code;
+    } catch (e) {
+        process.stdout.write(
+            `::warning::self-review-gate NEUTRAL — unexpected error (${e instanceof Error ? e.message : String(e)}); ` +
+                'nothing was reviewed, not a blocker.\n',
+        );
+        return 0;
     }
-    return code;
 }
 
 if (existsSync(process.argv[1] ?? '') && import.meta.url === `file://${process.argv[1]}`) {

package/src/scripts/skill_eval_coverage.ts

@@ -26,6 +26,12 @@
  *                  drops below the pinned floor (internal/evals/coverage-floor.json).
  *                  A missing floor file is treated as an all-zero floor
  *                  (bootstrap-inert: never fails before the first --write-floor).
+ *                  ALSO enforces the tier floor (road-to-fable-feedback-5
+ *                  Phase 4a, council 2026-07-10): every `priority`-tier skill
+ *                  (rich + default-surface + router) MUST carry a behavioural
+ *                  evals.json, unless exempted WITH a reason in
+ *                  internal/evals/tier-floor-exemptions.json. No silent
+ *                  exemptions — the bright line replaces weighted scoring.
  *   --write-floor  pin the current coverage as the new floor. Maintainer action
  *                  after authoring evals — the ratchet only ever rises.
  *
@@ -47,6 +53,7 @@ export interface CoverageOptions {
     skillsDir?: string;
     profilesDir?: string;
     floorPath?: string;
+    exemptionsPath?: string;
 }
 
 export interface TierCoverage {
@@ -222,6 +229,52 @@ export function writeFloor(opts: CoverageOptions = {}): CoverageReport {
     return report;
 }
 
+export function _exemptionsPath(opts: CoverageOptions = {}): string {
+    return (
+        opts.exemptionsPath ??
+        path.join(REPO_ROOT, 'internal', 'evals', 'tier-floor-exemptions.json')
+    );
+}
+
+function _readExemptions(p: string): Record<string, string> {
+    try {
+        const raw = JSON.parse(fs.readFileSync(p, 'utf-8')) as {
+            exemptions?: Record<string, unknown>;
+        };
+        const out: Record<string, string> = {};
+        for (const [k, v] of Object.entries(raw.exemptions ?? {})) {
+            if (typeof v === 'string' && v.trim().length > 0) out[k] = v;
+        }
+        return out;
+    } catch {
+        return {};
+    }
+}
+
+/**
+ * Tier floor: every priority-tier skill (rich + default-surface + router)
+ * must carry evals.json, unless exempted with a reason. Stale exemptions
+ * (exempted but now covered, or no longer priority) are reported so the
+ * list cannot silently accumulate.
+ */
+export function checkTierFloor(opts: CoverageOptions = {}): {
+    ok: boolean;
+    violations: string[];
+    stale: string[];
+} {
+    const report = computeCoverage(opts);
+    const exemptions = _readExemptions(_exemptionsPath(opts));
+    const uncovered = report.tiers.priority.uncovered;
+    const violations = uncovered
+        .filter((n) => !(n in exemptions))
+        .map((n) => `priority-tier skill '${n}' has no evals/evals.json and no exemption`);
+    const uncoveredSet = new Set(uncovered);
+    const stale = Object.keys(exemptions)
+        .filter((n) => !uncoveredSet.has(n))
+        .map((n) => `exemption for '${n}' is stale (covered or no longer priority-tier)`);
+    return { ok: violations.length === 0, violations, stale };
+}
+
 /** Ratchet: current coverage must be >= floor, overall and per tier. */
 export function checkRatchet(opts: CoverageOptions = {}): { ok: boolean; regressions: string[] } {
     const report = computeCoverage(opts);
@@ -281,12 +334,27 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
 
     if (argv.includes('--check')) {
         const { ok, regressions } = checkRatchet();
-        if (!ok) {
-            process.stdout.write('❌  eval-coverage ratchet regressed:\n');
-            for (const r of regressions) process.stdout.write(`    - ${r}\n`);
+        const floor = checkTierFloor();
+        if (!ok || !floor.ok) {
+            if (!ok) {
+                process.stdout.write('❌  eval-coverage ratchet regressed:\n');
+                for (const r of regressions) process.stdout.write(`    - ${r}\n`);
+            }
+            if (!floor.ok) {
+                process.stdout.write('❌  priority-tier eval floor violated:\n');
+                for (const v of floor.violations) process.stdout.write(`    - ${v}\n`);
+                process.stdout.write(
+                    '    Author a behavioural evals.json, or add an exemption WITH a reason\n' +
+                        '    to internal/evals/tier-floor-exemptions.json.\n',
+                );
+            }
             return 1;
         }
+        for (const s of floor.stale) {
+            process.stdout.write(`⚠️  ${s}\n`);
+        }
         process.stdout.write('✅  eval-coverage ratchet: no regression.\n');
+        process.stdout.write('✅  priority-tier eval floor: every rich/default-surface/router skill covered or exempted-with-reason.\n');
         return 0;
     }
 

package/src/scripts/skill_linter.ts

@@ -1416,6 +1416,7 @@ export function lint_skill(p: string, text: string): LintResult {
             'flux',
             'forecasting',
             'grafana',
+            'humanizer',
             'iconography',
             'laravel',
             'livewire',