@event4u/agent-config 14.10.0 → 14.12.0

package/src/scripts/trigger_coverage.ts

@@ -338,14 +338,18 @@ interface ParsedArgs {
     json: boolean;
     /** `rule` keeps the pinned byte-identical contract; `skill` is additive. */
     scope: 'rule' | 'skill';
+    /** `--ratchet`: compare the skill scope against its published baseline. */
+    ratchet: boolean;
 }
 
 function parse_args(argv: string[]): ParsedArgs {
-    const out: ParsedArgs = { json: false, scope: 'rule' };
+    const out: ParsedArgs = { json: false, scope: 'rule', ratchet: false };
     for (let i = 0; i < argv.length; i += 1) {
         const a = argv[i]!;
         if (a === '--json') {
             out.json = true;
+        } else if (a === '--ratchet') {
+            out.ratchet = true;
         } else if (a === '--scope') {
             const v = argv[i + 1];
             if (v !== 'rule' && v !== 'skill') {
@@ -355,7 +359,9 @@ function parse_args(argv: string[]): ParsedArgs {
             out.scope = v;
             i += 1;
         } else if (a === '-h' || a === '--help') {
-            process.stdout.write('usage: trigger_coverage [-h] [--json] [--scope rule|skill]\n');
+            process.stdout.write(
+                'usage: trigger_coverage [-h] [--json] [--scope rule|skill] [--ratchet]\n',
+            );
             process.exit(0);
         }
     }
@@ -372,6 +378,113 @@ function parse_args(argv: string[]): ParsedArgs {
  * its own change, not against a number invented on the day the instrument
  * shipped.
  */
+/** The published skill-coverage baseline `--ratchet` compares against. */
+export const SKILL_RATCHET_BASELINE = path.join(
+    REPO_ROOT,
+    'agents',
+    'evidence',
+    'metrics',
+    'skill-trigger-coverage-baseline.json',
+);
+
+export interface SkillRatchetBaseline {
+    skills_with_triggers: number;
+    activations: number;
+}
+
+/** Read the baseline, or `null` when none is published yet. */
+export function loadSkillRatchetBaseline(file = SKILL_RATCHET_BASELINE): SkillRatchetBaseline | null {
+    if (!fs.existsSync(file)) return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8')) as Record<string, unknown>;
+        const c = parsed['skills_with_triggers'];
+        const a = parsed['activations'];
+        if (typeof c !== 'number' || typeof a !== 'number') return null;
+        return { skills_with_triggers: c, activations: a };
+    } catch {
+        return null;
+    }
+}
+
+export interface RatchetVerdict {
+    ok: boolean;
+    lines: string[];
+}
+
+/**
+ * The Phase-3.2 ratchet, as a pure function of two readings.
+ *
+ * TWO directions, and only one of them is a floor. Coverage
+ * (`skills_with_triggers`) may only RISE — a tranche that removes triggers is
+ * the regression this exists to catch. Activations over the matrix may only
+ * FALL OR HOLD — that is the noise ceiling, and it is the half that makes
+ * seeding safe rather than merely measurable.
+ *
+ * A missing baseline is NOT a pass. It is `ok: false` with a line saying to
+ * publish one, because a ratchet that silently no-ops when its baseline is gone
+ * is the failure mode a ratchet exists to prevent.
+ */
+export function ratchetVerdict(
+    current: SkillRatchetBaseline,
+    baseline: SkillRatchetBaseline | null,
+): RatchetVerdict {
+    if (baseline === null) {
+        return {
+            ok: false,
+            lines: [
+                '❌  no published baseline — cannot ratchet.',
+                `    Publish one: {"skills_with_triggers": ${current.skills_with_triggers}, ` +
+                    `"activations": ${current.activations}}`,
+                `    at agents/evidence/metrics/skill-trigger-coverage-baseline.json`,
+            ],
+        };
+    }
+    const lines: string[] = [];
+    let ok = true;
+    if (current.skills_with_triggers < baseline.skills_with_triggers) {
+        ok = false;
+        lines.push(
+            `❌  coverage fell: ${baseline.skills_with_triggers} → ${current.skills_with_triggers} ` +
+                'skills declaring triggers. The ratchet only turns one way.',
+        );
+    } else {
+        lines.push(
+            `✅  coverage ${baseline.skills_with_triggers} → ${current.skills_with_triggers} ` +
+                'skills declaring triggers.',
+        );
+    }
+    if (current.activations > baseline.activations) {
+        ok = false;
+        lines.push(
+            `❌  matrix activations rose: ${baseline.activations} → ${current.activations}. ` +
+                'A tranche may raise coverage only without raising noise.',
+        );
+    } else {
+        lines.push(`✅  matrix activations ${baseline.activations} → ${current.activations}.`);
+    }
+    return { ok, lines };
+}
+
+function runSkillRatchetCli(json: boolean): number {
+    const report = runSkillScope(loadSkillTriggers(SKILLS_DIR), loadMatrixPrompts(MATRIX_DIR));
+    const current = {
+        skills_with_triggers: report.skills_with_triggers,
+        activations: report.activations,
+    };
+    const verdict = ratchetVerdict(current, loadSkillRatchetBaseline());
+    if (json) {
+        process.stdout.write(_jsonDumps({ current, ok: verdict.ok, lines: verdict.lines }) + '\n');
+        return verdict.ok ? 0 : 1;
+    }
+    for (const line of verdict.lines) process.stdout.write(`${line}\n`);
+    process.stdout.write(
+        verdict.ok
+            ? '\nskill-trigger ratchet: OK\n'
+            : '\nskill-trigger ratchet: FAILED\n',
+    );
+    return verdict.ok ? 0 : 1;
+}
+
 function runSkillScopeCli(json: boolean): number {
     const report = runSkillScope(loadSkillTriggers(SKILLS_DIR), loadMatrixPrompts(MATRIX_DIR));
     if (json) {
@@ -405,7 +518,13 @@ function runSkillScopeCli(json: boolean): number {
 
 export function main(argv: string[] | null = null): number {
     const args = parse_args(argv ?? process.argv.slice(2));
-    if (args.scope === 'skill') return runSkillScopeCli(args.json);
+    if (args.ratchet && args.scope !== 'skill') {
+        process.stderr.write('error: --ratchet requires --scope skill\n');
+        return 2;
+    }
+    if (args.scope === 'skill') {
+        return args.ratchet ? runSkillRatchetCli(args.json) : runSkillScopeCli(args.json);
+    }
 
     let isFile = false;
     try {

package/src/scripts/update_counts.ts

@@ -281,9 +281,13 @@ export const TARGETS: ReadonlyArray<[string, ReadonlyArray<[string, string]>]> =
             // claim names as its own method.
             ['(installs ships )(\\d+)( of )', 'skills_scoped'],
             ['( of )(\\d+)( skills \\(untagged core)', 'skills'],
-            // "14 of 111 governed rules" — the total was scanner-checked and
-            // generator-blind for the same reason.
-            ['( of )(\\d+)( governed rules \\()', 'rules'],
+            // The "N of M governed rules" position was retired on 2026-08-23:
+            // the `enforcement-coverage-resolved` entry no longer restates any
+            // enforcement figure, because five hand-written numbers for one
+            // property is the defect `check_enforcement_denominator` now reds
+            // on. The denominator lives in ONE place — the resolver's own output,
+            // projected into docs/proof.md § 4b — so there is no longer a
+            // literal here for a generator to keep in sync.
         ],
     ],
     [

package/src/scripts/validate_frontmatter.ts

@@ -872,6 +872,69 @@ export function check_obligation_frequency(
     ];
 }
 
+/**
+ * Shape check for a skill's optional `scope:` write-scope declaration.
+ *
+ * WHAT IT CHECKS, and only this: when `scope:` is present it carries exactly ONE
+ * of `verification_command` / `verification_reason`. The `access` enum, the
+ * `pattern` shape and the closed key set are `skill.schema.json`'s and are
+ * already enforced by {@link validate} — including through `skill_linter`, which
+ * calls the same validator. This covers the one constraint JSON Schema cannot
+ * express in the subset implemented here: **exactly one of two optional
+ * siblings**. `oneOf` / `anyOf` / `not` are not implemented (nor are
+ * `minProperties` / `maxProperties`), so a schema-only attempt would be silently
+ * inert — which is worse than absent, because it reads as enforced.
+ *
+ * WHY EXACTLY ONE. Neither branch is a formality. A declaration with NEITHER is a
+ * scope claim nobody can check and nobody has excused, which is the pro-forma
+ * field the whole shape exists to avoid. A declaration with BOTH reads as
+ * "verified, with an excuse attached" — and the excuse is the half a reader would
+ * act on, so the pair is strictly less informative than either alone.
+ *
+ * WHY IT LIVES HERE AND NOT IN `skill_linter.ts`. It was written there and
+ * `check_source_size_budget` refused it: `skill_linter.ts` is 4,742 lines, the
+ * ratchet sums lines ABOVE 1,500 per file, and 63 added lines were 63 new
+ * violations against a shrink-only baseline. Extracting the body to `_lib` still
+ * left the import plus the call, i.e. +2, and a ratchet turns one way. This file
+ * is 1,120 lines, so the same code costs zero — and it sits beside
+ * {@link check_obligation_frequency}, the existing precedent for an
+ * artefact-specific check that the generic validator cannot express.
+ *
+ * WHAT IT DOES NOT CHECK, stated plainly: whether the declared paths are the
+ * paths the skill actually writes. Nothing observes a skill's writes, so that
+ * half is model-carried and `scope:` is a declaration, not a control.
+ */
+export function check_scope_declaration(data: Record<string, YamlValue>): SchemaError[] {
+    const scope = data['scope'];
+    if (scope === null || typeof scope !== 'object' || Array.isArray(scope)) return [];
+    const keys = scope as Record<string, YamlValue>;
+    const hasCommand = typeof keys['verification_command'] === 'string';
+    const hasReason = typeof keys['verification_reason'] === 'string';
+    if (hasCommand && hasReason) {
+        return [
+            new SchemaError(
+                '$.scope',
+                'scope-verification-both',
+                'declares BOTH verification_command and verification_reason — exactly one. A reason ' +
+                    'beside a command reads as a verified claim with an excuse attached, and the excuse ' +
+                    'is the half a reader would act on.',
+            ),
+        ];
+    }
+    if (!hasCommand && !hasReason) {
+        return [
+            new SchemaError(
+                '$.scope',
+                'scope-verification-missing',
+                'declares neither verification_command nor verification_reason — exactly one. A scope ' +
+                    'claim with no command and no stated reason is unfalsifiable, which is the ' +
+                    'pro-forma field this declaration exists to avoid.',
+            ),
+        ];
+    }
+    return [];
+}
+
 // --- CLI entry point -------------------------------------------------------
 
 /** Yield `[artefact_type, path]` pairs for all lintable artefacts. */
@@ -999,6 +1062,9 @@ export function _main(argv: string[]): number {
             if (artefactType === 'rule') {
                 errors.push(...check_obligation_frequency(p, text, data));
             }
+            if (artefactType === 'skill') {
+                errors.push(...check_scope_declaration(data));
+            }
             const fatal = errors.filter((e) => e.severity === 'error');
             const warnings = errors.filter((e) => e.severity === 'warning');
             if (fatal.length > 0) {

package/src/server/schemas/settings.ts

@@ -511,6 +511,11 @@ export const settingsSchema = z.object({
                 'PreToolUse anti-slop nudge (road-to-anti-slop-detector Phase 3). Default off. When on, runs the lint_design_slop registry against about-to-be-written UI content and WARNS (never blocks) on P0/P1 aesthetic tells (side-stripe, gradient-text, magic z-index, …). Flags are rebuttable via DESIGN.md / design-slop-disable. Anti-loop: a file::rule signature surfaced 3x goes silent. Host-limited convenience layer; the universal gate is the lint_design_slop linter/CI.',
             ),
         }).default({}),
+        design_pass: z.object({
+            enabled: z.boolean().default(false).describe(
+                'PostToolUse + stop design pass (road-to-frontend-power E1.1/E1.2/E1.3). Default off. One concern on two slots: on post_tool_use a write to a UI surface delivers the design findings as context and never blocks; on stop the same pass runs over every UI file touched this session, deduped against what the post pass surfaced, and a P0 objective floor (contrast, font size, heading skip, focus) blocks with a continuation. P1-P3 never block. post_tool_use rather than pre_tool_use for two measured reasons: pre_tool_use is declared by three hosts and honoured by one while post_tool_use is declared by six, and _lib/ui_surface.ts is a path predicate, so a pre-write gate cannot fire on the first write of a new surface. A pass that could not fully run reports verification: degraded with a reason rather than passing silently. Does not replace design_slop: two design keys is the honest state until the tiering experiment has a number.',
+            ),
+        }).default({}),
         ui_route_nudge: z.object({
             enabled: z.boolean().default(false).describe(
                 'PreToolUse UI-route nudge (road-to-frontend-skill-application Phase 4). Default off. When on, a Write/Edit to a UI surface with no design consultation latched this session WARNS (never blocks) naming the route — run existing-ui-audit, then the fe-design loop. A read or search touching fe-design / existing-ui-audit / design-review / design-intelligence latches consultation and silences it for the session. Anti-loop: at most 2 nudges per session. It does not read the rules: the UI-surface decision comes from _lib/ui_surface.ts and no code parses rule frontmatter, so this runs parallel to the two UI rules rather than consuming their triggers, and a test keeps the sets from drifting. It is a nudge, so their enforced_by: none stays accurate.',
@@ -521,6 +526,11 @@ export const settingsSchema = z.object({
                 'PreToolUse code-graph nudge (ADR-124 Phase 4). Default off. When on AND a native code-graph cache or a consumer-shipped graph.json/SCIP index is present, warns once per session (never blocks) as the agent is about to Grep/Glob or Read a source file — query the graph first for who-calls/where-used/impact questions (or rebuild if stale, build if absent). Source G’s strict block-first-read mode is deliberately un-ported.',
             ),
         }).default({}),
+        suggestion_capture: z.object({
+            enabled: z.boolean().default(false).describe(
+                'Suggestion-block capture (road-to-suggestion-block-capture Phase 2). Default off. Two slots: `stop` reads `last_assistant_message` — a payload field, so no transcript file is read — and latches that the assistant turn carried a numbered-options block; `user_prompt_submit` CONSUMES that latch and classifies the answering turn as option_n / as_is / other / stale_block. Consume-once is the correctness guard: the latch is deleted on read, so a bare "1" three turns later meets no latch and classifies `other`, and a latch past its TTL or unparseable is `stale_block` rather than a guess. Writes COUNTS ONLY to agents/runtime/state/audit/suggestion-capture.jsonl — the record type has no field able to hold a prompt, an option label or a command name, and a test asserts the written key set against src/config/suggestion-capture.json. Off by default because this is an INSTRUMENT rather than a feature: it exists so a capture rate can be measured on a maintainer workspace over a fixed soak window, and there is nothing in it for a consumer to gain.',
+            ),
+        }).default({}),
         // `turn_end_gate` is deliberately ABSENT. The stop-slot turn-end gate is
         // always armed (2026-08-12) and has no settings surface: whether it
         // fires is decided by each detector's own trigger conditions, not by a

package/src/shared/skillRanking.ts

@@ -0,0 +1,183 @@
+/**
+ * skillRanking — the ONE definition of "how relevant is this skill to this task".
+ *
+ * WHY IT LIVES HERE. Two callers need the identical answer and were about to
+ * grow two implementations of it:
+ *
+ *   - `src/scripts/skill_tools/score_skill_relevance.ts` — the disk-reading
+ *     ranker behind the kernel MCP server's `suggest_skill_for_task` and the
+ *     `skill-route` hook.
+ *   - `src/cli/mcp/dispatch.ts` — the turnkey stdio server, which must stay a
+ *     pure function of its in-memory content tree and therefore cannot call a
+ *     module that walks the file system.
+ *
+ * `road-to-skill-delivery-over-mcp` risk 6 names that fork by name: "two
+ * implementations of `suggest_skill_for_task` diverge silently". The fix is to
+ * put the formula in one Node-free module both can import, which is what this
+ * is. `src/shared/` is the only directory in the tree that both `src/scripts/`
+ * and `src/cli/` already import from, and it is required to stay Node-free —
+ * exactly the constraint the pure dispatcher needs.
+ *
+ * THE FORMULA IS UNCHANGED. It is the Python-parity scorer ported in ADR-200,
+ * moved rather than rewritten: `score = round(term_overlap * 70 + persona_hit *
+ * 30)`, half-to-even, over tokens of the skill's `name + description`. The
+ * `score_skill_relevance` CLI's argparse-parity suite is the check that the move
+ * changed nothing.
+ *
+ * THE ONE ADDITION is `triggerTerms`, off by default. Phase 3.1 of the same
+ * roadmap indexes `triggers.keyword` / `triggers.phrase` text; it is an opt-in
+ * parameter rather than a second function so the two rankers can be measured
+ * against each other on one corpus.
+ *
+ * Pure — no imports, no I/O, no clock.
+ */
+
+// re.compile(r"[a-z][a-z0-9]+") — applied to the lowercased text.
+const TOKEN_RE = /[a-z][a-z0-9]+/g;
+
+/** Ported verbatim from the Python scorer. Order is irrelevant; membership is not. */
+export const STOPWORDS: ReadonlySet<string> = new Set([
+    'the', 'a', 'an', 'and', 'or', 'but', 'of', 'for', 'with', 'to', 'in',
+    'on', 'at', 'by', 'from', 'as', 'is', 'are', 'was', 'were', 'be', 'been',
+    'this', 'that', 'these', 'those', 'it', 'its', 'use', 'when', 'even',
+    'via', 'via:', 'into', 'onto', 'use:', 'skill', 'skills', 'task', 'tasks',
+    'code', 'file', 'files', 'doing', 'make', 'do', 'go', 'get', 'set',
+    'not', 'no', 'yes', 'any', 'some', 'all', 'one', 'two', 'new', 'old',
+    'user', 'users', 'our', 'your', 'their', 'they', 'we', 'you', 'i', 'me',
+]);
+
+/** Mirror Python `len(str)` — count Unicode code points, not UTF-16 units. */
+function pyLen(s: string): number {
+    let n = 0;
+    for (const _ of s) n++;
+    return n;
+}
+
+/** Mirror Python `round(x)` — half-to-even. Exact for integral ndigits. */
+export function roundHalfToEven(x: number): number {
+    if (!Number.isFinite(x)) return x;
+    const floor = Math.floor(x);
+    const frac = x - floor;
+    if (frac < 0.5) return floor;
+    if (frac > 0.5) return floor + 1;
+    return floor % 2 === 0 ? floor : floor + 1;
+}
+
+/** Lowercase, extract `[a-z][a-z0-9]+`, drop stopwords and tokens of ≤2 code points. */
+export function tokenize(text: string): Set<string> {
+    const out = new Set<string>();
+    const matches = text.toLowerCase().match(TOKEN_RE) ?? [];
+    for (const t of matches) {
+        if (!STOPWORDS.has(t) && pyLen(t) > 2) out.add(t);
+    }
+    return out;
+}
+
+/**
+ * Which `triggers[]` keys carry INDEXABLE PROSE.
+ *
+ * `file_pattern`, `path_prefix` and `command` are match *mechanisms*, not text a
+ * prompt is compared against: folding a glob in would put tokens like `blade` and
+ * `php` on every skill that merely watches a path. `reason` documents the trigger
+ * for a human and is not part of what it matches. The policy lives here because
+ * two different readers apply it to two different input shapes — parsed YAML
+ * objects in `src/cli/mcp/content.ts`, flat `key: "value"` lines in the
+ * frontmatter reader of `score_skill_relevance.ts` — and only the DECISION is
+ * shared, not the parsing.
+ */
+export const INDEXED_TRIGGER_KEYS: readonly string[] = ['keyword', 'phrase'];
+
+/**
+ * Trigger prose out of flat `key: "value"` frontmatter lines.
+ *
+ * The stdlib-only frontmatter reader in `score_skill_relevance.ts` flattens
+ *   triggers:
+ *     - phrase: "authorization check"
+ * to the single string `phrase: "authorization check"`, so this takes that shape
+ * rather than an object. Anything whose key is not indexable is dropped.
+ */
+export function triggerTextFromFlatLines(lines: readonly string[]): string[] {
+    const out: string[] = [];
+    for (const line of lines) {
+        const m = /^([a-zA-Z_][\w-]*)\s*:\s*(.*)$/.exec(String(line).trim());
+        if (!m) continue;
+        if (!INDEXED_TRIGGER_KEYS.includes(m[1]!)) continue;
+        const value = m[2]!.trim().replace(/^["']|["']$/g, '');
+        if (value) out.push(value);
+    }
+    return out;
+}
+
+/** A skill as the ranker sees it. Deliberately not the body — see `rankSkills`. */
+export interface RankableSkill {
+    name: string;
+    description: string;
+    personas?: readonly string[];
+    /** `triggers[].keyword` / `triggers[].phrase` text. Indexed only on request. */
+    triggerText?: readonly string[];
+}
+
+export interface RankOptions {
+    /** Phase 3.1: fold `triggerText` into the indexed terms. Default false (keyword-v1). */
+    includeTriggers?: boolean;
+}
+
+/** The indexed term set for one skill, under the given options. */
+export function skillTerms(skill: RankableSkill, opts: RankOptions = {}): Set<string> {
+    const parts = [skill.name, skill.description];
+    if (opts.includeTriggers && skill.triggerText) parts.push(...skill.triggerText);
+    return tokenize(parts.join(' '));
+}
+
+/**
+ * The score. `taskTerms` is `tokenize(task)`; `terms` is `skillTerms(skill)`.
+ *
+ * Both are passed in rather than derived here so a caller ranking N skills
+ * tokenizes the task once and each skill once, which is what makes this usable
+ * on a per-prompt hook path.
+ */
+export function scoreSkill(
+    taskTerms: ReadonlySet<string>,
+    skill: RankableSkill,
+    terms: ReadonlySet<string>,
+): number {
+    if (taskTerms.size === 0) return 0;
+    let inter = 0;
+    for (const t of taskTerms) if (terms.has(t)) inter++;
+    const overlap = inter / Math.max(taskTerms.size, 1);
+    let personaHit = 0;
+    const taskLower = [...taskTerms].join(' ');
+    for (const persona of skill.personas ?? []) {
+        const slug = String(persona).toLowerCase();
+        if (taskLower.includes(slug) || slug.split('-').some((part) => taskTerms.has(part))) {
+            personaHit = 1;
+            break;
+        }
+    }
+    return roundHalfToEven(overlap * 70 + personaHit * 30);
+}
+
+export interface RankedSkill {
+    name: string;
+    score: number;
+    personas: string[];
+}
+
+/**
+ * Rank an in-memory skill set. Zero scores are dropped; ties break on name, so
+ * the result is a total order and two callers with the same input agree.
+ */
+export function rankSkills(
+    task: string,
+    skills: readonly RankableSkill[],
+    opts: RankOptions = {},
+): RankedSkill[] {
+    const taskTerms = tokenize(task);
+    const rows: RankedSkill[] = [];
+    for (const skill of skills) {
+        const score = scoreSkill(taskTerms, skill, skillTerms(skill, opts));
+        if (score > 0) rows.push({ name: skill.name, score, personas: [...(skill.personas ?? [])] });
+    }
+    rows.sort((a, b) => (b.score - a.score) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return rows;
+}

package/dist/agent-src/skills/accessibility-auditor/evals/evals.json

@@ -1,15 +0,0 @@
-{
-  "skill": "accessibility-auditor",
-  "_calibration": "Behavioural fixtures (road-to-skill-eval-coverage Phase 2, rich set). Deterministic `contains` asserts a real WCAG audit property (the standard is cited); finding_floor n=2 is a conservative floor (an icon-button with no name + a placeholder-only input surface ≥2 issues), not a calibrated per-host number; the rubric names the specific missing control as a pinned-judge known-limit.",
-  "scenarios": [
-    {
-      "id": "audit-icon-button-and-placeholder-input",
-      "prompt": "Audit this UI for accessibility and list each issue as its own bullet point:\n```html\n<button onclick=\"save()\"><svg width=\"16\" height=\"16\"></svg></button>\n<input type=\"text\" placeholder=\"Email address\">\n```",
-      "assertions": [
-        { "kind": "finding_floor", "n": 2, "pattern": "(?m)^\\s*[-*+]\\s+" },
-        { "kind": "contains", "value": "WCAG" },
-        { "kind": "rubric", "criterion": "Names the icon-only button's missing accessible name (aria-label / visible label) AND the placeholder-not-a-label problem on the input." }
-      ]
-    }
-  ]
-}

package/dist/agent-src/skills/agent-security-review/evals/triggers.json

@@ -1,52 +0,0 @@
-{
-    "skill": "agent-security-review",
-    "last_eval": "2026-06-16",
-    "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers DE + EN phrasings for adversarial review of an agent's CONFIG/behaviour (rules, skills, MCP, hooks, permissions). Should-not-trigger covers the near-miss neighbours (code threat-model, code security-audit, the static config-audit command, privacy review, dependency CVE scan) whose vocabulary overlaps.",
-    "queries": [
-        {
-            "q": "red-team my agent setup — could someone weaponise my CLAUDE.md or MCP servers?",
-            "trigger": true
-        },
-        {
-            "q": "do an adversarial security review of this agent config and its skills",
-            "trigger": true
-        },
-        {
-            "q": "is this third-party skill pack safe to install, attacker's view?",
-            "trigger": true
-        },
-        {
-            "q": "prüfe meine Agent-Konfiguration adversarial auf Angriffsketten",
-            "trigger": true
-        },
-        {
-            "q": "what could an attacker do with my rules files, hooks and tool permissions?",
-            "trigger": true
-        },
-        {
-            "q": "threat-model this new payments endpoint before I build it",
-            "trigger": false,
-            "note": "code change threat model → threat-modeling"
-        },
-        {
-            "q": "find vulnerabilities in my application code",
-            "trigger": false,
-            "note": "code vulnerability hunt → security-audit"
-        },
-        {
-            "q": "give me an A-F score for my agent config",
-            "trigger": false,
-            "note": "static scored audit → /security-audit-config command, not the adversarial skill"
-        },
-        {
-            "q": "are we GDPR compliant with this data flow?",
-            "trigger": false,
-            "note": "regulatory-regime read → privacy-review"
-        },
-        {
-            "q": "scan my dependencies for known CVEs",
-            "trigger": false,
-            "note": "dependency CVE audit → security-audit dependency pass"
-        }
-    ]
-}

package/dist/agent-src/skills/ai-code-blindspots/evals/triggers.json

@@ -1,52 +0,0 @@
-{
-    "skill": "ai-code-blindspots",
-    "last_eval": "2026-07-09",
-    "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers DE + EN phrasings for the pre-ship 'what invisible cross-cutting controls did the AI omit?' checklist across code surfaces. Should-not-trigger covers near-miss neighbours (deep single-surface skills, prose/docs edits, adversarial config review) whose vocabulary overlaps.",
-    "queries": [
-        {
-            "q": "I just wrote this endpoint — what invisible controls did I forget before I call it done?",
-            "trigger": true
-        },
-        {
-            "q": "run the senior pre-ship checklist over this diff for cross-cutting controls",
-            "trigger": true
-        },
-        {
-            "q": "what does AI-generated code usually omit here — authz, tenant scope, validation?",
-            "trigger": true
-        },
-        {
-            "q": "prüf meinen Code auf die unsichtbaren Kontrollen, die die KI weglässt",
-            "trigger": true
-        },
-        {
-            "q": "before I finish this migration and query, what am I blind to?",
-            "trigger": true
-        },
-        {
-            "q": "review this React component specifically for XSS and client secrets",
-            "trigger": false,
-            "note": "single frontend surface → frontend-render-security"
-        },
-        {
-            "q": "is this npm package safe to add?",
-            "trigger": false,
-            "note": "dependency intake → supply-chain-intake"
-        },
-        {
-            "q": "threat-model this new payments endpoint before I build it",
-            "trigger": false,
-            "note": "pre-build threat model → threat-modeling / security-sensitive-stop"
-        },
-        {
-            "q": "fix the typo in this README",
-            "trigger": false,
-            "note": "prose/docs edit — no code surface"
-        },
-        {
-            "q": "red-team my agent's CLAUDE.md and MCP config",
-            "trigger": false,
-            "note": "agent-config adversarial review → agent-security-review"
-        }
-    ]
-}

package/dist/agent-src/skills/analysis-skill-router/evals/evals.json

@@ -1,13 +0,0 @@
-{
-  "skill": "analysis-skill-router",
-  "_calibration": "Behavioural fixtures (road-to-skill-eval-coverage Phase 2, router set). Deterministic `contains` asserts the router picks the NARROWEST matching project-analysis-* skill (the whole routing contract) — a mis-route names the wrong or a generic skill.",
-  "scenarios": [
-    {
-      "id": "route-laravel-slow-queries",
-      "prompt": "Analyze why our Laravel app's database queries are slow. Which analysis skill should handle this?",
-      "assertions": [
-        { "kind": "contains", "value": "project-analysis-laravel" }
-      ]
-    }
-  ]
-}

package/dist/agent-src/skills/brand/evals/triggers.json

@@ -1,17 +0,0 @@
-{
-  "skill": "brand",
-  "last_eval": "2026-06-16",
-  "description": "5 should-trigger + 5 should-not-trigger. Should-trigger covers grounding a brand decision against the corpus (archetype, voice, colour, naming, archetype->type). Should-not-trigger covers near-miss neighbors: UI style grounding (design-intelligence), token authoring (design-tokens), generating a logo asset (logo-generation), validation of emitted artifacts (brand-consistency), and font-pairing lookup without a brand frame (typography-system style path).",
-  "queries": [
-    {"q": "which brand archetype fits a rugged outdoor gear company?", "trigger": true},
-    {"q": "ground the voice and tone for a challenger fintech brand", "trigger": true},
-    {"q": "what colour direction does the corpus suggest for a children's education brand?", "trigger": true},
-    {"q": "which naming pattern suits a coined-word tech startup brand?", "trigger": true},
-    {"q": "what type pairing-filter does a luxury law firm archetype imply?", "trigger": true},
-    {"q": "which UI style and palette fit a fintech dashboard?", "trigger": false, "note": "frontend style grounding → design-intelligence, not brand strategy"},
-    {"q": "emit the brand colours as DTCG CSS variables", "trigger": false, "note": "token authoring/emission → design-tokens / brand-to-tokens"},
-    {"q": "generate a logo image for this bakery", "trigger": false, "note": "asset generation → logo-generation, not brand grounding"},
-    {"q": "check whether this landing page copy is on-brand", "trigger": false, "note": "post-action validation → brand-consistency rule"},
-    {"q": "what's a good serif font pairing for a magazine?", "trigger": false, "note": "font-pairing lookup with no brand frame → typography-system style path"}
-  ]
-}

package/dist/agent-src/skills/brand-asset-generation/evals/triggers.json

@@ -1,17 +0,0 @@
-{
-  "last_eval": "2026-06-16",
-  "should_trigger": [
-    "Generate a banner for our product launch — use the brand colors from .tokens.json",
-    "Create a social card for the Open Graph meta tag, 1200×630, matching our brand palette",
-    "Make a LinkedIn cover image using our brand typography and voice",
-    "Generate a CIP header element for the website hero section with brand-token injection",
-    "Produce a branded social media image for the campaign — we have pack-brand installed"
-  ],
-  "should_not_trigger": [
-    "Design a logo for our new startup",
-    "Generate a product photo of a coffee mug on a white background",
-    "Which image provider should I use for text-heavy images?",
-    "Write a prompt for Midjourney to create a realistic landscape",
-    "Create a brand strategy document outlining our positioning and target audience"
-  ]
-}