@event4u/agent-config 8.13.0 → 9.0.0

package/docs/guidelines/agent-infra/domain-adoption-gates.md

@@ -0,0 +1,112 @@
+# Domain Adoption — Gates
+
+> The three-gate evidence contract, sunset policy, and failure-mode catalog for the `domain-adoption-policy` rule
+
+_Origin: migrated from `src/rules/domain-adoption-policy.md` per the P4 pattern of `road-to-kernel-and-router.md`. The Iron Law and the three gate names stay in the rule; this file carries the per-gate evidence bars and procedures._
+
+## Gate 1 — Demand signal
+
+At least one of the following must be **true and citeable** in the roadmap:
+
+- **≥ 2 consumer projects** in the domain. Cite repository names or
+  `agents/settings/contexts/` notes — not "I think there might be".
+- **Named user direction with target.** A specific user ask plus a target
+  project / use case — e.g. "harvest the mobile skills for project X, due
+  next quarter". Vague *"this might be useful"* does not count.
+- **Public-incident pull.** A reproducible incident on a consumer project
+  the domain would have prevented, captured in `agents/settings/contexts/` with
+  the missing surface area named.
+
+If none of the three is citeable, **defer**. Open a watch-only context note
+under `agents/settings/contexts/domain-watch/<domain>.md` listing the missing signal
+so the next harvest can re-evaluate without re-relitigating the case.
+
+## Gate 2 — Named maintenance owner
+
+Domain plates rot. Pick the owner before the import, not after.
+
+- The roadmap names a **single maintainer** (not "the team", not "TBD")
+  responsible for the domain quarterly review.
+- The owner commits to the **refresh cadence** — quarterly review at
+  minimum, faster if the domain is volatile (mobile RN/Expo SDK,
+  ML model APIs).
+- Each adopted artefact carries an **inline upstream-source line** with
+  SHA + last-checked timestamp so refresh is mechanical, not archaeological.
+
+If no owner is named or no cadence is set, **defer**. An unowned domain
+plate becomes broken authoritative-links and stale skills inside two cycles.
+
+## Gate 3 — CI-tooling decision
+
+Either the domain's verification tooling is validated in CI, or the suite
+explicitly accepts platform-bound reference-only status.
+
+- **Validated.** The CI pipeline runs the relevant linters/tests/integration
+  checks for the domain (e.g. `mobile-e2e` runners, ML model validation,
+  contract conformance) on every PR. Cost noted in the roadmap risk
+  register.
+- **Out-of-scope (reference-only).** The domain is a platform fact the
+  suite cannot validate (iOS Simulator on non-macOS runners, GPU-bound
+  ML, hardware-bound IoT). The roadmap states this explicitly; affected
+  artefacts carry a "reference-only on \<unsupported platforms\>" header
+  so consumers do not file false-positive bugs.
+
+If neither line is drawn, **defer**. Half-validated CI silently rots the
+domain — green builds while the underlying tooling drifts.
+
+## Sunset Policy stacks on top
+
+Every domain track inherits the authoritative-link Sunset path documented
+in any plate that imports volatile upstream content:
+
+- Volatile content (SDK-pinned, API-pinned, tool-version-pinned) lives as
+  guideline body + SHA-pinned upstream link, not as forked scripts.
+- Refresh trigger: quarterly cadence or earlier if a SHA-pinned link
+  404s in CI.
+- The `check-refs` and `check-portability` linters apply unchanged.
+
+Adopting a domain does not exempt it from any other suite-wide rule —
+`augment-edit-discipline`, `skill-quality`, `size-enforcement`,
+`rule-type-governance`. Every domain artefact passes the same gates as a
+core artefact.
+
+## Failure modes
+
+- *"It's just one skill, not a domain."* — Audit the skill's prerequisites.
+  If it pulls in a new toolchain, simulator, language runtime, or
+  platform-specific build system, it **is** a domain entry. Run the gates.
+- *"The upstream is well-maintained, we can just track it."* — Tracking
+  upstream means owning the diff, the breaking changes, and the migrations.
+  Tracking is maintenance work; budget for it under Gate 2 or skip the
+  adoption.
+- *"We'll add CI later."* — Later does not arrive. Either CI is wired in
+  the same plate, or the artefacts ship with explicit reference-only
+  headers so users do not assume validated coverage.
+- *"Council convergence is enough."* — Council informs the gates; it does
+  not replace them. A council session may surface that all three gates
+  pass; the roadmap still cites the evidence.
+- *"Demand-signal is the user asking once."* — Single-shot interest is a
+  watch trigger, not an open trigger. Either name the target use case
+  with project + timeline, or open a watch note and wait.
+
+## What to do when the gates fail
+
+1. Mark the domain plate `[-] gated — <gate name> not met` in the relevant
+   roadmap. Do **not** silently shrink scope to dodge the gate.
+2. Open a watch-only context note under `agents/settings/contexts/domain-watch/`
+   capturing what's missing — citations, owner candidates, CI feasibility.
+3. Re-evaluate at the next harvest cycle. The note is the evidence trail
+   so the same questions are not relitigated.
+
+## Allowed without gates
+
+- Adding **a single skill** to an **already-opened** domain follows the
+  regular harvest plate; the gates do not re-fire per skill.
+- Authoring a **guideline** that documents a domain the suite already
+  ships in — the domain is open, the guideline is a within-domain artefact.
+- A **rule** that constrains an already-opened domain — within-domain.
+
+## See also
+
+- `domain-adoption-policy` (rule) — the Iron Law + gate names.
+- `size-enforcement` · `rule-type-governance` · `skill-quality` — the suite-wide floors every domain artefact still passes.

package/docs/guidelines/agent-infra/framework-neutrality-patterns.md

@@ -0,0 +1,66 @@
+# Framework Neutrality — Patterns
+
+> Forbidden-pattern table, cross-stack documentation allowance, and carve-out pointer shape for the `framework-neutrality-in-generic-skills` rule
+
+_Origin: migrated from `src/rules/framework-neutrality-in-generic-skills.md` per the P4 pattern of `road-to-kernel-and-router.md`. The Iron Law, scope, and exemption list stay in the rule; this file carries the pattern reference._
+
+## Forbidden patterns in generic artifacts
+
+| Pattern | Why it leaks | Fix |
+|---|---|---|
+| `FormRequest` as a mandate | Laravel-only validation class | Say "request-validation primitive (FormRequest in Laravel, zod in Next.js, pydantic in FastAPI)" or move to `laravel-validation` carve-out |
+| `php artisan …` as a canonical command | Laravel CLI | Generalize to "the framework's CLI" or move to `artisan-commands` carve-out |
+| `PHPStan` as the only example | PHP-only static analyser | List peers (`mypy` for Python, `tsc` for TypeScript) or move to `quality-tools` carve-out |
+| `composer.json` mentioned alone | PHP package manifest | Add `package.json` / `pyproject.toml` peers, or move to a PHP-scoped carve-out |
+| `Eloquent` / `Model::…` | Laravel ORM | Generalize to "the project's ORM/data layer" or move to `eloquent` carve-out |
+| `Pest` as the only test runner | PHP/Laravel test framework | List peers (`pytest`, `vitest`, `jest`) or move to `pest-testing` carve-out |
+| `Blade` / `Livewire` / `Flux` as default UI | Laravel view stack | Generalize to "the project's UI layer" or move to `blade-ui` / `livewire` / `flux` carve-outs |
+| `vendor/bin/<tool>` as a canonical path | PHP/Composer-specific binary path | Say "the project's quality CLI" or carve-out it |
+| `Rector` as the only refactor tool | PHP-only refactorer | List peers (`ts-morph`, `libcst`) or carve-out it |
+| "every controller" / "all controllers" | Assumes MVC PHP framework | Generalize to "every request handler" / "every endpoint" |
+
+## Allowed: cross-stack documentation
+
+Multi-stack tables or detection maps with **at least two ecosystems
+side-by-side** are documentation, not leakage. The linter's
+auto-detect heuristic skips a hit when its ±2-line window contains
+patterns from a different ecosystem family (`php_family` vs
+`js_family` vs `python_family`).
+
+Example (allowed):
+
+```
+- PHP/Composer project → `composer.json` present
+- Node project        → `package.json` present
+- Python project      → `pyproject.toml` present
+```
+
+## Allowed: carve-out pointers
+
+A generic artifact may end a section with a one-line handoff to its
+framework-specific peers. Canonical shape:
+
+```
+→ Laravel-specific: see [laravel-validation](../skills/laravel-validation/SKILL.md)
+→ Next.js-specific: see [nextjs-patterns](../skills/nextjs-patterns/SKILL.md)
+```
+
+The pointer is a link, not a procedure — the generic artifact never
+inlines stack-specific code.
+
+## Enforcement
+
+`scripts/lint_framework_leakage.ts` runs in the package CI pipeline.
+Exit codes:
+
+- `0` — no hits, or every hit is auto-detected as cross-stack, or
+  every hit is allowlisted in
+  `scripts/lint_framework_leakage_allowlist.json` with a `reason`.
+- `1` — at least one hit in a generic artifact (non-carve-out) that
+  is neither cross-stack nor allowlisted.
+
+## See also
+
+- `framework-neutrality-in-generic-skills` (rule) — Iron Law, scope, exemption list.
+- `roadmap-ci-steps-policy` — sibling Tier-2a rule that drove this pattern.
+- `skill-quality` — every skill must remain executable; carve-outs must still pass skill-quality.

package/docs/guidelines/agent-infra/minimal-safe-diff-mechanics.md

@@ -0,0 +1,99 @@
+# Minimal Safe Diff — Mechanics
+
+> Anti-over-engineering criteria, larger-change guidance, break-glass exception, and the bounded remediation carve-out for the `minimal-safe-diff` rule
+
+_Origin: migrated from `src/rules/minimal-safe-diff.md` per the P4 pattern of `road-to-kernel-and-router.md`. The Iron Law, "The rule", "Before writing the diff", the red-flags list, and "Own-orphan cleanup" (anchor-referenced by `downstream-changes`) stay in the rule; this file carries the worked criteria._
+
+## When the task seems to require a larger change
+
+- A rename, restructure, or framework upgrade that crosses the minimal-diff
+  line is a **separate, explicit** task — ask the user before expanding.
+- A bug fix that exposes a broader design problem stays a bug fix. Log the
+  design problem as a follow-up (ticket, note, TODO) and ship the fix alone.
+- A new feature that tempts you to "clean up" the module first: resist.
+  Add the feature, commit it, then propose the cleanup as a separate change.
+
+## Auto-formatter or linter rewrites unrelated code
+
+Revert those hunks before staging. The diff you present is the diff you own.
+If project policy forbids partial formatting, split into two commits:
+*format only* · *behavior change*.
+
+## Anti-over-engineering
+
+The smallest change is also the least *abstract* and least *speculative* one:
+
+- **Three similar lines beat a premature abstraction.** Do not extract a helper
+  / generic / config layer to dedupe two or three call sites — inline
+  repetition is cheaper to read and change than the wrong abstraction. Per new
+  abstraction: **cite the second caller — or inline it.**
+- **No speculative features.** Nothing beyond what was asked: no
+  configurability or "flexibility" nobody requested, no parameters with one
+  call site, no error handling for scenarios that cannot occur in this
+  codebase.
+- **The rewrite trigger.** If the change could be half the size without losing
+  behavior, rewrite before presenting. Self-check: *"Would a senior engineer
+  call this overcomplicated?"* — if yes, simplify.
+- **No tombstones.** Delete removed code completely — no `_oldName` renames,
+  no `// removed X` / `// no longer used` markers, no dead re-export shims kept
+  "for safety". Git history is the tombstone.
+- **No docstrings/comments on untouched code.** Do not annotate code the diff
+  does not change.
+
+Wrong/right pairs for each ban:
+[`simplicity-and-goal-demos`](simplicity-and-goal-demos.md)
+— the demos are the recognition surface; match your diff against the *right*
+column before presenting.
+
+**Not adopted (council):** the source's "validate only at system boundaries /
+trust internal code" clause is **rejected** — internal code can be wrong, and
+"trust" is not a testing strategy. Keep validating internal invariants; this
+fold is about *diff shape*, not about dropping internal checks.
+
+## Break-glass exception
+
+The rule stays in force during production incidents. "Break-glass mode"
+narrows verification (see `verify-before-complete`) — it does **not**
+license drive-by edits.
+
+Allowed during break-glass:
+
+- The **smallest** change that stops the bleeding — one file, one
+  method, one guard — preferred over any refactor.
+- A fast revert to a known-good commit, even if it undoes unrelated
+  improvements shipped in the same PR.
+
+Not allowed, even in break-glass:
+
+- "While I'm in there" cleanups, reformatting, or dependency bumps.
+- Expanding the fix to neighboring modules without evidence they are
+  part of the incident.
+- Merging the hotfix with pending refactors from another branch.
+
+After the incident, open a **follow-up PR** for any scope that was
+intentionally deferred and reference the break-glass commit in its
+description.
+
+## Bounded remediation carve-out
+
+The default stands: no drive-by edits, no opportunistic refactors. The one
+bounded exception — a **small, task-aligned security/correctness fix in code
+the current task already touches** — is governed by `active-remediation`
+(mechanics: [`active-remediation-mechanics`](active-remediation-mechanics.md)).
+It is permitted inline **only** when ALL hold: same request path / module,
+≤ ~10 changed lines in one production file (plus its test file), no
+public-API / response-shape change, no dependency bump or migration, and its
+verification (e.g. the negative test) ships in the same commit. Anything
+outside those five conditions is **not** this carve-out — it is note + ask
+per `active-remediation`. This never licenses reformatting, renames,
+dependency bumps, or version upgrades (a syntax-idiom modernization is
+allowed only under `active-remediation`'s version-gated,
+behavior-preserving clause; a dependency/version bump stays ask-only). The
+sole case that may interrupt is a **live cross-user/tenant data exposure**
+(`broken-access-control`) — fix-now-if-small, else stop and surface; never
+defer it silently.
+
+## See also
+
+- `minimal-safe-diff` (rule) — Iron Law, the rule, pre-diff checklist, red flags, own-orphan cleanup.
+- [`active-remediation-mechanics`](active-remediation-mechanics.md) — the fix-now / note+ask / follow-up-PR ladder detail.

package/docs/guidelines/agent-infra/skill-quality-checklist.md

@@ -17,6 +17,19 @@ Every skill must answer four questions. If ANY answer is weak, the skill is not
 | 3 | How do I verify it worked? | `Procedure` (validation step) | Concrete checks, not "verify it works" |
 | 4 | What common failure must I avoid? | `Gotcha` + `Do NOT` | Real failure patterns, not platitudes |
 
+## Register — explain the trade-off, except in the safety kernel
+
+Two registers, chosen by artifact class (U4, ecosystem harvest 2026-07-13):
+
+- **Capability skills** (workflows, analyses, generators) **explain the
+  trade-off** — say *why* the recommended path beats the alternative instead of
+  shouting ALL-CAPS MUSTs; an agent that understands the why generalizes to
+  cases the skill never enumerated.
+- **The safety kernel keeps its imperative Iron-Law register** — kernel rules,
+  safety floors (`*-safety-floor`), and Hard-Floor surfaces stay ALL-CAPS
+  fenced-law imperative, non-negotiable (`preservation-guard` enforces the
+  byte-level protection). Never downgrade an Iron Law to friendly prose.
+
 ## Required Sections
 
 Every skill MUST have: `When to use`, `Procedure`, `Gotcha`, `Output format`, `Do NOT`.

package/docs/guidelines/design-fidelity-mechanics.md

@@ -0,0 +1,76 @@
+# Design Fidelity — Mechanics
+
+> Surgical-edit discipline, asset & imagery floor, and the failure-mode catalog for the `design-fidelity` rule
+
+_Origin: migrated from `src/rules/design-fidelity.md` per the P4 pattern of `road-to-kernel-and-router.md`. The Iron Law, the `design.fidelity_mode` strictness table, and the fire/not-fire scope stay in the rule; this file carries the illustrative depth._
+
+## Surgical visual edits
+
+A request to change one visual thing — a colour, a label, a single element — is
+a **targeted edit**, not a redesign licence. Apply the same
+`minimal-safe-diff` discipline to design work that backend edits have
+always owed.
+
+- **Change only the semantic target.** Preserve the surrounding layout,
+  spacing, typography, dimensions, content, animation, and interaction states.
+  Do not rewrite the component, reflow the section, or "modernise" neighbours
+  while you are in there. (fixtures: `daf-edit-preservation`, `daf-unwanted-variations`.)
+- **A broader redesign needs an explicit trigger.** Only phrases like *"new
+  direction"*, *"from scratch"*, *"make it feel premium"*, *"rework the flow"*,
+  or *"give me variations / options"* license a from-scratch rework. Absent such
+  a phrase, a "fix / change / update the X" request is surgical — when unsure
+  which, ask (`ask-when-uncertain`). (fixture: `daf-redesign-trigger`.)
+- **Preserve stable anchors.** Where the host exposes DOM/comment metadata, keep
+  comment anchors and screen labels intact so the edit stays locatable. Where
+  the host has no such surface, preserve stable semantic anchors already present
+  in source comments / `data-*` attributes — never strip them, and do not invent
+  new ones.
+
+## Asset & imagery discipline
+
+Visual artifacts carry **real assets or honest placeholders — never fabricated
+brand evidence**. The design-surface instance of the no-invented-facts floor.
+
+- **Copy owned assets through the project's accepted path.** Reference or copy
+  project-owned assets (logos, icons, fonts, images) via the target project's
+  asset directory/pipeline — never hotlink a design-system's internal URL, never
+  bulk-copy a huge source folder. (fixtures: `daf-missing-asset`, `daf-external-asset-url`.)
+- **Real imagery where inspection matters.** On visual pages/decks, use actual
+  product / place / object / state imagery where the image IS the proof (a
+  product screenshot, a real dashboard state). Decorative atmosphere is not proof
+  — never pass a stock-like or invented image off as the real product. An
+  invented product screenshot is fabricated evidence. (fixture: `daf-invented-screenshot`.)
+- **Icons follow the iconography floor** — no emoji-as-icon in serious UI, no
+  hand-rolled icon when a set exists; see the `iconography` skill § Iconography floor.
+- **Ask before adding material — no unrequested filler.** Never generate copy,
+  placeholder sections, or decorative blocks the user did not ask for to "complete"
+  a design. Brief silent on a region → surface the gap (`ask-when-uncertain`)
+  or leave an honest placeholder; never invent filler to fill space.
+
+## Failure modes
+
+- Swapping the prototype's font / typeface because another "reads better".
+- Replacing a specified control (slider, stepper, chip) with a different control.
+- Dropping or adding an element the prototype shows ("+", a send→stop toggle, a warning chip).
+- Restructuring layout or moving sections "because the flow is better".
+- Treating an internal "honesty gate" or "stub" concern as licence to redesign the UI.
+- Re-running a redesign after the user already said "match the prototype".
+
+## How to surface a deviation — do NOT execute it
+
+Name what the spec shows, what you would change, and why — as a numbered option
+per `user-interaction`. The user picks. Honesty about **behaviour** (a control
+not yet wired) never licenses changing the **design**: a faithful visual plus a
+labelled "not wired yet" note beats an invented redesign.
+
+## Fixtures
+
+Behavioral baseline: the `daf-*` fixtures named above (edit preservation,
+unwanted variations, redesign trigger, missing asset, external asset URL,
+invented screenshot).
+
+## See also
+
+- `design-fidelity` (rule) — Iron Law + `design.fidelity_mode` strictness table.
+- `brand-source-of-truth` / `brand-consistency` — same precedence shape, for registered brand tokens.
+- [`design-modes.md`](design-modes.md) — brand vs product register discriminator.

package/docs/parity/command-frontmatter.md

@@ -0,0 +1,60 @@
+# Command frontmatter — per-host projection parity
+
+> Which command frontmatter fields each host bridge actually consumes, and the
+> deliberate divergences from the official command-authoring field standard.
+> Source of truth for command definitions: `src/domains/<pack>/<name>/command.md`
+> (projected verbatim to `dist/agent-src/commands/` by the condensation
+> pipeline). Schema: [`command.schema.json`](../../src/scripts/schemas/command.schema.json).
+> Roadmap origin: `road-to-ecosystem-harvest-skill-quality-gates` Phase 4 (Source C).
+
+## Projection paths per host
+
+| Host | Projection | Frontmatter reaches host? |
+|---|---|---|
+| Claude Code | `.claude/skills/<slug>/SKILL.md` — symlink to the command source; rendered copy (with native `model:`) when `model.auto_switch: auto` and a `model_tier` maps | Yes — full frontmatter, verbatim |
+| Cursor | `.cursor/commands/<slug>.md` — symlink to the command source | Yes — file verbatim; Cursor treats unknown frontmatter as inert |
+| Windsurf | `.windsurf/workflows/<slug>.md` — symlink to the command source | Yes — same inert-passthrough as Cursor |
+| Cline / Gemini / Copilot / Roo / Codex / Continue | Text reference via `AGENTS.md` only (no native command surface) | No — invocation is conversational |
+
+## Field consumption matrix (official-standard fields)
+
+| Field | Claude Code | Cursor / Windsurf | Notes |
+|---|---|---|---|
+| `name` | ✅ load rule: must equal the skill directory slug | inert | Path-derived hyphen slug; enforced by `check_host_loadability` |
+| `description` | ✅ routing + display | inert | ≤ 200 chars per schema |
+| `argument-hint` | ✅ rendered next to the slash command | inert | Added Phase 4; set on every command whose body documents an invocation argument (140/183 at introduction) |
+| `disable-model-invocation` | ✅ honored natively | inert (vacuously true — no model-invocation surface) | Schema pins `enum: [true]` — commands are user-invoked by design |
+| `model` | ✅ (rendered copies only) | inert | Never authored by hand: the generator rewrites `model_tier:` → native `model:` at projection time (ADR-034/035) |
+
+All other fields (`tier`, `visibility`, `pack`, `cluster`, `intent`,
+`routes_to`, `replaces`, `suggestion`, `workspaces`, `packs`, `trust`,
+`install`, `model_tier`, …) are **suite governance metadata** — consumed by the
+package's own linters, router, discovery manifest, and docs generators, never
+by a host. Hosts that read the file verbatim ignore them; that is the intended
+contract, not drift.
+
+## Deliberate divergences from the official standard
+
+1. **No colon names.** The official examples allow `/cluster:sub` invocation;
+   this suite forbids colons in `name:` (Agent-Skills-spec compliance for
+   strict consumers like Zed). Claude Code's `/cluster:sub` invocation still
+   works — it is path-derived from `commands/<cluster>/<sub>.md`, not from the
+   `name:` field.
+2. **`disable-model-invocation` is locked to `true`.** The standard allows
+   model-invocable commands; this suite's commands are always user-invoked
+   (`command-suggestion-policy` owns proactive surfacing instead — suggest,
+   never invoke).
+3. **`model` is generated, never authored.** Authors declare the
+   vendor-neutral `model_tier:`; the Claude bridge renders a native `model:`
+   only when the consumer opted into `model.auto_switch: auto`.
+4. **`argument-hint` is host-passthrough.** Only Claude Code renders it today;
+   it stays in the neutral source (harmless elsewhere) rather than being
+   projected host-specifically — per the do-NOT-chase-host-fields rule for the
+   neutral tree.
+
+## Verification
+
+- `./scripts-run src/scripts/validate_frontmatter` — every command validates
+  against the schema (including `argument-hint` shape, ≤ 120 chars).
+- `./scripts-run src/scripts/check_host_loadability --root .` — generated
+  `.claude/skills/` entries parse and satisfy the host load rule.

package/docs/proof.md

@@ -29,6 +29,7 @@ evidence pointer, or `task check-claims` fails the build.
 | The release process is documented as an inheritable runbook + succession doc, and the project's bus-factor (trailing-90-day distinct human reviewers) is tracked and reported truthfully — currently 1, not implied to be more. | qual | `docs/succession.md#trailing 90 days` | ✅ |
 | 183 commands. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
 | A MEASURED-BUT-NOT-SHIPPED experiment — the thin rule projection reduced eager rule load 78,513 → 13,881 GPT-tokens (whole always-loaded projection 98,529 → 33,897, ~65.6%), but FAILED the quality gate (thin win-rate 36.2% vs required 48%) and does not ship; it un-defers only behind `discipline_profile: essential`. Shipped behavior does NOT include this reduction. Method: `agent-config benchmark` over the pinned token baseline; the baseline is the honest "what the user pays if everything loads eagerly", NOT a synthetic full-corpus strawman (council Q4); quality gate per the Phase-0 paired judge run. | quant | `internal/bench/reports/token-baseline.json#eager_rule_load` | ✅ |
+| The first cross-vendor parity pass (5 orchestration-corpus tasks × 2 vendors × 3 repeats, identical prompts via the council transport, $0.16) measured real per-host finding-count differences — claude-sonnet-4-5 surfaced ~2× the findings of gpt-4o on the multi-file analysis task (median 11 vs 5) while both vendors were identical on the planted hollow-implementation task (2 vs 2) and perfectly silent on the clean-code negative control (0 vs 0, no spurious findings). The per-task `finding_floor` values are calibrated from the cross-host lower envelope and the gate is armed. | quant | `internal/bench/reports/parity-count.json#min over hosts of median` | ✅ |
 | On a weak host (claude-haiku-4-5) the package produces a significant, placebo-controlled discipline lift on scope/downstream traps; on a strong host the same measurement is a published null — the package transplants discipline a weak model lacks, not model intelligence. | quant | `docs/benchmark.md#weak-host-specific` | ✅ |
 | The non-coding domain skills (finance/founder/ops/content) are forged on TS/PHP and labeled unvalidated until they pass a sourced domain-truth fixture; no public prose implies proven domain correctness, and the validated count is CI-ratcheted. | qual | `src/scripts/domain_soundness_status.ts#checkRatchet` | ✅ |
 | The validated non-coding domain-skill count is pinned and CI-ratcheted at a maintainer-set floor (9 of 20 default-surface skills carry a sourced `evals/domain-truth.json` fixture at pin time, 2026-07-11 — 5 deterministic, keys from cited formulas; 4 rubric, criteria matching a named external practice); the floor only rises via a maintainer `--write-floor` after a new sourced fixture lands. | quant | `internal/evals/domain-soundness-floor.json#validated` | ✅ |
@@ -44,10 +45,10 @@ evidence pointer, or `task check-claims` fails the build.
 | On a deterministic multi-session recall corpus, the memory substrate produces a measured, placebo-controlled recall lift — memory-on 27/27 vs no-memory 10/27 and vs equal-byte placebo 9/27 (claude-haiku-4-5, n=9 tasks x 3 seeds, sign test p=0.031 for BOTH pairings). Scoped honestly: this is the context-value upper bound (perfect retrieval on a one-fact-per-task corpus), not retrieval precision under a large store. | quant | `internal/bench/reports/second-brain-delta.json` | ✅ |
 | Removing the perfect-retrieval assumption, the substrate's REAL keyword retrieval recalls the needed decision into the top-5 under keyword-overlapping confusers (precision@5 9/9) and the model disambiguates it from the co-injected confusers — retrieval-on 27/27 vs no-memory 5/27 and vs equal-count placebo 5/27 (claude-haiku-4-5, 9 tasks x 3 seeds, sign test p=0.008 both). Named limit: retrieval RECALLS but does not RANK (mean tie-set 3.3, ties broken by store order, not relevance) — the discrimination gap that motivates the SQLite-FTS5 activation path (ADR-116) at larger scale. | quant | `internal/bench/reports/second-brain-retrieval.json` | ✅ |
 | Every artifact the package ships — source AND the condensed projection that reaches consumers — is machine-scanned in CI for hidden-Unicode, mixed-script-confusable, and instruction-smuggling payloads (the rules-file-backdoor class); a finding blocks the release before `npm publish`, not just the merge. | qual | `.github/workflows/publish-npm.yml#lint_agent_security` | ✅ |
-| 271 skills. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
+| 274 skills. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
 | Removes only its own keys from a shared host config (matched by JSON-pointer + SHA-256), never a neighbour tool's entries. | qual | `docs/contracts/install-layout.md#JSON-pointer` | ✅ |
 
-**20 backed claim(s)** — all evidence pointers resolve in CI.
+**21 backed claim(s)** — all evidence pointers resolve in CI.
 
 Artefact counts in public prose (skills, commands, governed rules,
 guidelines, personas) are **generated from source and CI-drift-checked**:
@@ -76,11 +77,11 @@ shipping theater; the full per-cell data is committed at
 `internal/bench/reports/persona-placebo.json`.
 
 **Behavioural-eval coverage — the honest baseline.** Skill *quality* is only
-as good as its measurement. Today **39 of 271** skills carry a behavioural
+as good as its measurement. Today **42 of 274** skills carry a behavioural
 `evals.json`; the highest-traffic / highest-cost tiers (default-surface +
 `rich` + routers) are **fully covered (35 of 35)**, the long tail
-(4 of 236) is not. We publish that gap rather than imply
-"271 evaluated skills": coverage is measured per tier
+(7 of 239) is not. We publish that gap rather than imply
+"274 evaluated skills": coverage is measured per tier
 (`./scripts-run src/scripts/skill_eval_coverage`), **CI-ratcheted so it can
 only rise**, and the priority tiers carry a hard **tier floor**: every
 rich / default-surface / router skill MUST have a behavioural eval or an

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@event4u/agent-config",
-    "version": "8.13.0",
+    "version": "9.0.0",
     "description": "Universal AI Agent OS — audited skills, governance rules, commands, and templates for AI coding tools (Claude Code, Cursor, Windsurf, Copilot).",
     "license": "MIT",
     "private": false,

package/src/agent-src/templates/scripts/telemetry/engagement.ts

@@ -15,6 +15,10 @@
  *       "boundary_kind": "task" | "phase-step" | "tool-call",
  *       "consulted": {"skills": [...], "rules": [...], ...},
  *       "applied":   {"skills": [...], "rules": [...], ...},
+ *       "loaded":    {"skills": [...], "rules": [...], ...}  # optional (U1a):
+ *              what was AVAILABLE/INJECTED at the boundary — the Fired/Loaded
+ *              denominator. Superset contract: consulted ⊆ loaded. Ids only
+ *              (same PII-exclusion-by-construction shape as consulted).
  *       "outcomes":  ["blocked", "verification_failed", ...]  # optional
  *       "tokens_estimate": {"consulted_load": <int>}   # optional
  *     }
@@ -127,6 +131,7 @@ export interface EngagementEventInit {
     boundary_kind: string;
     consulted?: Record<string, string[]>;
     applied?: Record<string, string[]>;
+    loaded?: Record<string, string[]> | null;
     outcomes?: string[] | null;
     tokens_estimate?: Record<string, number> | null;
     schema_version?: number;
@@ -138,6 +143,7 @@ export class EngagementEvent {
     boundary_kind: string;
     consulted: Record<string, string[]>;
     applied: Record<string, string[]>;
+    loaded: Record<string, string[]> | null;
     outcomes: string[] | null;
     tokens_estimate: Record<string, number> | null;
     schema_version: number;
@@ -148,6 +154,7 @@ export class EngagementEvent {
         this.boundary_kind = init.boundary_kind;
         this.consulted = init.consulted ?? {};
         this.applied = init.applied ?? {};
+        this.loaded = init.loaded ?? null;
         this.outcomes = init.outcomes ?? null;
         this.tokens_estimate = init.tokens_estimate ?? null;
         this.schema_version = init.schema_version ?? SCHEMA_VERSION;
@@ -171,6 +178,20 @@ export class EngagementEvent {
         }
         _validate_artefact_dict('consulted', this.consulted);
         _validate_artefact_dict('applied', this.applied);
+        if (this.loaded !== null) {
+            _validate_artefact_dict('loaded', this.loaded);
+            for (const [kind, ids] of Object.entries(this.consulted)) {
+                const avail = new Set(this.loaded[kind] ?? []);
+                for (const art_id of ids) {
+                    if (!avail.has(art_id)) {
+                        throw new EngagementSchemaError(
+                            `consulted.${kind} id '${art_id}' missing from loaded.${kind}; `
+                            + 'superset contract: consulted \u2286 loaded',
+                        );
+                    }
+                }
+            }
+        }
         if (this.outcomes !== null) {
             _validate_outcomes(this.outcomes);
         }
@@ -206,6 +227,12 @@ export class EngagementEvent {
             consulted: _normalise_artefact_dict(this.consulted),
             applied: _normalise_artefact_dict(this.applied),
         };
+        if (this.loaded !== null) {
+            const norm = _normalise_artefact_dict(this.loaded);
+            if (Object.keys(norm).length > 0) {
+                out['loaded'] = norm;
+            }
+        }
         if (this.outcomes && this.outcomes.length > 0) {
             out['outcomes'] = [...this.outcomes];
         }
@@ -310,6 +337,9 @@ export function parse_event(line: string): EngagementEvent {
         boundary_kind: (r['boundary_kind'] as string) ?? '',
         consulted: _orEmptyDict(r['consulted']),
         applied: _orEmptyDict(r['applied']),
+        loaded: r['loaded'] === undefined || r['loaded'] === null
+            ? null
+            : _orEmptyDict(r['loaded']),
         outcomes: (r['outcomes'] as string[] | null | undefined) ?? null,
         tokens_estimate: (r['tokens_estimate'] as Record<string, number> | null | undefined) ?? null,
         schema_version: r['schema_version'] === undefined

package/src/agent-src/templates/scripts/telemetry/report_renderer.ts

@@ -121,15 +121,19 @@ export function render_markdown(aggregate: AggregateResult, opts: RenderOptions
             lines.push('');
             continue;
         }
-        lines.push('| kind | id | consulted | applied | applied/consulted | last seen |');
-        lines.push('|---|---|---:|---:|---:|---|');
+        const withLoaded = aggregate.loaded_events > 0;
+        lines.push(withLoaded
+            ? '| kind | id | loaded | consulted | applied | fired/loaded | applied/consulted | last seen |'
+            : '| kind | id | consulted | applied | applied/consulted | last seen |');
+        lines.push(withLoaded ? '|---|---|---:|---:|---:|---:|---:|---|' : '|---|---|---:|---:|---:|---|');
         for (const entry of rows) {
             const s = entry.stat;
             check_id_redaction(`buckets.${s.kind}.id`, s.artefact_id);
-            lines.push(
-                `| ${s.kind} | \`${s.artefact_id}\` | ${s.consulted} | ${s.applied} `
-                + `| ${_pyFixed(s.applied_ratio, 2)} | \`${s.last_seen_ts}\` |`,
-            );
+            lines.push(withLoaded
+                ? `| ${s.kind} | \`${s.artefact_id}\` | ${s.loaded} | ${s.consulted} | ${s.applied} `
+                    + `| ${_pyFixed(s.fired_ratio, 2)} | ${_pyFixed(s.applied_ratio, 2)} | \`${s.last_seen_ts}\` |`
+                : `| ${s.kind} | \`${s.artefact_id}\` | ${s.consulted} | ${s.applied} `
+                    + `| ${_pyFixed(s.applied_ratio, 2)} | \`${s.last_seen_ts}\` |`);
         }
         lines.push('');
     }
@@ -147,7 +151,9 @@ export function render_json(aggregate: AggregateResult, opts: RenderOptions = {}
         [BUCKET_BOTTOM]: [],
     };
     for (const entry of bucketed) {
-        (grouped[entry.bucket] as Array<Record<string, unknown>>).push(_stat_to_dict(entry.stat));
+        (grouped[entry.bucket] as Array<Record<string, unknown>>).push(
+            _stat_to_dict(entry.stat, aggregate.loaded_events > 0),
+        );
     }
     if (top !== null) {
         for (const bucket of Object.keys(grouped)) {
@@ -179,9 +185,9 @@ export function render_json(aggregate: AggregateResult, opts: RenderOptions = {}
     return `${_py_json_dumps_indent2_sorted(payload)}\n`;
 }
 
-function _stat_to_dict(stat: ArtefactStat): Record<string, unknown> {
+function _stat_to_dict(stat: ArtefactStat, withLoaded = false): Record<string, unknown> {
     check_id_redaction(`buckets.${stat.kind}.id`, stat.artefact_id);
-    return {
+    const out: Record<string, unknown> = {
         kind: stat.kind,
         id: stat.artefact_id,
         consulted: stat.consulted,
@@ -189,6 +195,13 @@ function _stat_to_dict(stat: ArtefactStat): Record<string, unknown> {
         applied_ratio: new PyFloat(_pyRound(stat.applied_ratio, 4)),
         last_seen_ts: stat.last_seen_ts,
     };
+    // U1a: emitted only when the log carries the loaded denominator, so
+    // pre-U1a logs render byte-identically to the frozen parity oracle.
+    if (withLoaded) {
+        out['loaded'] = stat.loaded;
+        out['fired_ratio'] = new PyFloat(_pyRound(stat.fired_ratio, 4));
+    }
+    return out;
 }
 
 // ── Python-parity helpers ───────────────────────────────────────────────