@event4u/agent-config 9.1.0 → 9.3.0

package/docs/design/adversarial-council-eval.md

@@ -0,0 +1,106 @@
+# Adversarial verification council eval — two-stage residual-detection design
+
+> Design artifact for `road-to-adversarial-verification-council` Phase 4. It
+> pins the benchmark that resolves the pre-registered `adversarial-council-
+> finding-coverage` claim (docs/CLAIMS.md, ADR-122). Writing this design is
+> autonomous; **curating the corpus and running the paid cross-vendor arm is a
+> maintainer cost decision**, gated on the corpus-validity check below.
+
+## What the claim is — and is not
+
+- **Is:** does a cross-vendor skeptic panel find materially more of the defects
+  that **survive a single strong judge** (the residual pool), at a false-positive
+  rate no worse than that judge on a controversial-but-correct control?
+- **Is not:** whether the council beats a solo model on *decision quality* — that
+  is the separate, `unbacked`, spend-gated `council-vs-solo-baseline`
+  (docs/design/council-vs-solo-baseline.md), explicitly out of scope.
+
+## The council's load-bearing critique (folded in)
+
+The AI-council debate (2026-07-14, anthropic/claude-sonnet-4-5 + openai/gpt-4o)
+converged on one real risk: the existing `cross-model-parity` corpus was built
+to show that different vendors catch different **obvious** things (parity), not
+to simulate the **residual** state after a competent first pass. Running the
+registered claim on it would force an honest-null as a *measurement artifact*,
+not a mechanism result. This design answers that with a two-stage protocol, a
+corpus-subtlety bar, a dual threshold, and a controversial-clean FP control.
+
+## Two-stage protocol
+
+1. **Stage 1 — single strong judge.** A single cross-model judge runs on every
+   planted-defect change. The defects it CATCHES are removed from scope.
+2. **Stage 2 — the panel on the residual.** Only the changes that PASS stage 1
+   (defect not caught) proceed to the Mode 9 panel. Recall is measured on this
+   **judge-passed residual pool** — the production-relevant quantity.
+
+This makes "residual detection" explicit rather than implicit in corpus
+selection.
+
+## Corpus-validity gate (blocks the registered run)
+
+The corpus must contain **judge-survivable subtleties**, published as a
+distribution before the registered run:
+
+- multi-file interaction defects,
+- subtle logic inversions that read as plausible,
+- security masked by correct-looking patterns,
+- edge cases in complex state.
+
+Publish the severity/subtlety distribution (share single-file <5 LoC vs
+multi-file interaction). A corpus skewed to trivially-detectable defects fails
+this gate — the registered run does not proceed until it passes.
+
+### Assessment of the existing corpus (2026-07-14)
+
+`internal/bench/orchestration/corpus/` (5 tasks: orch-01..03, pv-01 hollow,
+pv-02 control) was purpose-built for the parity signal and for A3
+production-validator Gate-A. `pv-01` is a deliberately **obvious** hollow impl
+(a floor sanity check), and none of the five tasks is designed as a
+judge-survivable residual defect. **Conclusion: this corpus does NOT meet the
+subtlety bar** — so the registered run is **blocked** pending a curated
+residual-defect corpus. The claim stays `unbacked` until then (no false
+`backed`).
+
+## Controversial-but-correct FP control
+
+The clean control includes correct-but-non-obvious cases (real perf/security
+design tradeoffs, uncommon patterns) — not only obviously-clean code — so the
+red-team posture's true FP cost is measured. Panel FP is compared to the
+single-judge FP on the SAME control.
+
+## Panel = cross-vendor
+
+The registered run and the opt-in high-risk tier use >=2 distinct **providers**
+(e.g. anthropic + openai), via the council transport (`council_cli.ts`,
+artefact/diff-as-text, read-only). The backed `cross-vendor-parity` signal is
+provider-level; same-vendor model diversity is insufficient for the claim.
+
+## The gate (locked at pre-registration)
+
+Encoded in [`src/scripts/_lib/adversarial_council_gate.ts`](../../src/scripts/_lib/adversarial_council_gate.ts)
+(`evaluateCouncilBench`), covered by `adversarial_council_gate.test.ts`:
+
+- (a) relative residual-recall lift >= **+25%**, AND
+- (b) absolute residual-recall lift >= **+8 pp**, AND
+- panel FP not worse than single-judge FP within the noise margin.
+
+Both recall thresholds are required — the dual gate guards the base-rate
+compression the council flagged (a high single-judge baseline makes relative
+lift easy but absolute must still clear). Threshold values are **locked**;
+corpus/protocol may be refined *before* the registered run, never the threshold
+after seeing results.
+
+## Outcome handling
+
+- **Pass** → flip `docs/CLAIMS.md#adversarial-council-finding-coverage` to
+  `backed` with the report pointer; document the recommended cross-vendor config.
+- **Honest-null** → record it (ADR-122 addendum + `docs/benchmark.md`), keep the
+  surface `off` by default permanently, mark the roadmap null-but-shipped-inert
+  (like recursive-verification).
+
+## Status
+
+- Gate logic: **built + tested** (deterministic TS).
+- Corpus-validity gate: **assessed — existing corpus fails the subtlety bar.**
+- Registered paid cross-vendor run: **deferred**, blocked on curating a
+  judge-survivable-subtlety corpus. Claim remains `unbacked`.

package/docs/development.md

@@ -112,9 +112,18 @@ task tool-validate             # Validate tool declarations
 
 ```bash
 task install -- --target <dir> # Run the installer orchestrator on a target
-task install-hooks             # Install git hooks (pre-commit marketplace lint, pre-push sync check, chat-history bridges)
+task install-hooks             # Install git hooks (pre-commit marketplace lint, pre-push consistency gate, chat-history bridges)
 ```
 
+The **pre-push hook runs `task consistency`** — the exact local mirror of the CI
+"Sync + Generate Tools Consistency" gate (sync + hashes + generate-tools +
+router + corpus + `git diff --quiet`). Any derived-output drift (counts, dist,
+generated tool trees) is blocked **before** the push instead of failing remote
+CI; the fix is `task consistency-fix`, stage, re-push. The hook auto-installs on
+`npm install` in a git clone (the `prepare` script); run `task install-hooks`
+manually if you skipped install scripts. Bypass a genuine WIP push with
+`git push --no-verify`.
+
 ### Local dev install (no release)
 
 Use these tasks to run the working tree as if it were a published

package/docs/featured-skills.md

@@ -1,6 +1,6 @@
 # Featured Skills
 
-A curated subset of the 275 skills. Three tiers, one per primary audience. Full catalog lives in [`dist/agent-src/skills/`](../dist/agent-src/skills/); see also [`docs/catalog.md`](catalog.md) for the complete index and [`docs/featured-commands.md`](featured-commands.md) for command-level highlights.
+A curated subset of the 276 skills. Three tiers, one per primary audience. Full catalog lives in [`dist/agent-src/skills/`](../dist/agent-src/skills/); see also [`docs/catalog.md`](catalog.md) for the complete index and [`docs/featured-commands.md`](featured-commands.md) for command-level highlights.
 
 > **Eval-gated messaging note.** Until `task bench --corpus non-dev` reports `selection_accuracy >= 0.60` (see `road-to-product-adoption.md` Phase 1), this page is documentation, not marketing. The entries below are the candidates the corpus tests against; their description quality is what the eval validates.
 
@@ -92,4 +92,4 @@ task lint-featured-skills
 
 CI runs this in `taskfiles/ci-fast.yml`. Stale entries (renamed / removed skill or command) fail the build. See [`scripts/lint_featured_skills.py`](../src/scripts/lint_featured_skills.py) for the matcher.
 
-→ Browse all 275 skills: [`dist/agent-src/skills/`](../dist/agent-src/skills/) · all 184 commands: [`dist/agent-src/commands/`](../dist/agent-src/commands/)
+→ Browse all 276 skills: [`dist/agent-src/skills/`](../dist/agent-src/skills/) · all 189 commands: [`dist/agent-src/commands/`](../dist/agent-src/commands/)

package/docs/getting-started-by-role.md

@@ -2,7 +2,7 @@
 
 > Pick the entry that matches what you do day-to-day. Each section names the three skills you will reach for first and shows whether MCP (no terminal) or CLI (terminal) is the simpler install path for that role.
 
-`agent-config` ships 275 skills, 104 governed rules, and 184 commands. You do not need all of them. Each role below filters to the slice that pays back in week one; the rest stays available and shows up on demand when a task references it.
+`agent-config` ships 276 skills, 105 governed rules, and 189 commands. You do not need all of them. Each role below filters to the slice that pays back in week one; the rest stays available and shows up on demand when a task references it.
 
 > **Taglines at a glance →** [`docs/role-experiences.md`](role-experiences.md) — the one-line pitch per role experience, in one table.
 

package/docs/getting-started.md

@@ -134,7 +134,7 @@ Your agent is now:
 - **Respecting your codebase** — no conflicting patterns
 - **Following standards** — consistent code quality
 
-This is enforced automatically by 104 rules. No configuration needed.
+This is enforced automatically by 105 rules. No configuration needed.
 
 ---
 

package/docs/governance-advantage.md

@@ -33,7 +33,7 @@ the host lacks (a static host gives it no runtime attention guarantee, but a
 runtime-only system gives it nothing at all here). A runtime-only system contributes *nothing* on these hosts.
 
 ### 2. Intent routing, not a 500-artefact dump
-A prompt does not load all 275 skills. `dist/router.json` (100 routed rules, intent →
+A prompt does not load all 276 skills. `dist/router.json` (101 routed rules, intent →
 skill, keyword/phrase/path triggers) carries the right skill on intent. The
 governance value is *selection discipline* — the host gets the relevant rule
 set, not the whole catalogue as context ballast.

package/docs/guidelines/agent-infra/cross-source-consistency-mechanics.md

@@ -0,0 +1,109 @@
+# Cross-Source Consistency — Mechanics
+
+> The discrepancy taxonomy, the scan procedure, the confidence-tiered noise control, worked examples, and the precedence table for the `cross-source-consistency` rule
+
+_Companion to `src/rules/cross-source-consistency.md` (P4 pattern of `road-to-kernel-and-router.md`). The Iron Law, the fire/not-fire scope, and the subordination clauses stay in the rule; this file carries the taxonomy detail, the scan procedure, and the examples._
+
+## The discrepancy taxonomy
+
+| # | Class | Definition | Canonical example |
+|---|---|---|---|
+| a | **text ↔ image** | The ticket/spec text contradicts an attached mockup, screenshot, or diagram. | Text: "show birthdays **today**". Mockup: a birthday from two days ago. |
+| b | **silent-but-needed** | The spec is silent on a behavior that is clearly required for the feature to be correct. | Spec: weekend-shifting only. Clearly also needed: public-holiday shifting — but never specified. |
+| c | **spec ↔ codebase/reality** | The spec contradicts what the code, DB, API, or a real source actually does. | Spec: "the endpoint returns `dueDate`". The DTO has no such field. |
+| d | **intra-ticket** | Acceptance criteria, description, and comments contradict each other. | Description: real-time. AC: "nightly batch is fine." |
+
+Type (a) and (d) are **contradictions between present sources** — the agent
+must not pick one silently. Type (b) is a **scope decision** — the inferred
+behavior may be right, but adding it is a scope expansion the user owns. Type
+(c) routes the *verification* to `source-discovery` (read the real source); this
+rule only owns *surfacing the conflict and asking*.
+
+## The scan procedure
+
+Run this whenever planning, refining, estimating, roadmapping, or implementing
+from a ticket/spec that carries a second source:
+
+1. **Enumerate the sources.** Ticket text, every attachment (mockup / screenshot
+   / diagram), the AC block, description, comments, and — for implementation —
+   the relevant codebase/DB/API surface. If an attachment cannot be read,
+   say so; do not assume it agrees.
+2. **Compare pairwise for type (a), (c), (d).** For each pair, ask: do they state
+   the same thing about the same requirement? A mismatch is a discrepancy.
+3. **Scan for type (b) — silence.** List the behaviors the feature obviously
+   needs but the spec never mentions (weekend/holiday shifts, empty states,
+   error paths, permission edges, pagination, timezone). Each unstated-but-needed
+   behavior is a candidate to surface — not to implement.
+4. **Classify confidence.** High = the sources plainly disagree, or the missing
+   behavior is clearly load-bearing. Low = the "conflict" is a plausible
+   re-reading, or the missing behavior may be intentionally out of scope.
+5. **Decide per the setting** (below), then **batch** every surviving discrepancy
+   into ONE question folded into this turn's single `ask-when-uncertain` prompt.
+
+## Confidence-tiered noise control (`consistency.cross_source`)
+
+The rule fires only under a real trade-off (it must pass the
+`no-cheap-questions` Pre-Send Self-Check). The setting tunes how aggressively:
+
+| Value | High-confidence discrepancy | Low-confidence discrepancy |
+|---|---|---|
+| `on` (default) | Surface + ask before proceeding. | Surface + ask (batched into the same question). |
+| `auto` | Surface + ask. | State as an explicit assumption and proceed (no question). |
+| `off` | No cross-source checking — legacy behavior. | No cross-source checking. |
+
+Batching is the anti-noise mechanism: N discrepancies for one artefact become
+one numbered-options block, never N prompts. Plain vagueness (a single unclear
+source, no second source to compare) is **not** a discrepancy — it stays with
+`ask-when-uncertain` so the two disciplines never double-fire on the same input.
+
+## Worked examples
+
+### Example 1 — text ↔ image (type a)
+
+Ticket: *"The tile shows employees who have their birthday **today**."* Attached
+mockup: a card with a birthday dated **two days ago**.
+
+- Wrong: implement "today" (or implement "recent, like the mockup") and move on.
+  Both are silent guesses on a real contradiction — a violation even if the
+  chosen reading turns out correct.
+- Right: *"The ticket text says 'today' but the mockup shows a birthday from two
+  days ago. Which is authoritative — (1) strictly today, (2) a recent window as
+  the mockup implies, (3) something else?"* Then implement the confirmed reading;
+  `design-fidelity` governs building it 1:1 afterwards.
+
+### Example 2 — silent-but-needed (type b)
+
+Ticket update: *"If a birthday falls on the weekend, show it on the next
+workday."* The spec never mentions public holidays.
+
+- Wrong: also shift birthdays that fall on a public holiday, because it is
+  "obviously" consistent with the weekend rule — a silent scope expansion.
+- Right: *"The spec covers weekend-shifting but is silent on public holidays.
+  Should birthdays on a public holiday also shift to the next workday? (1) yes,
+  same as weekends, (2) no, holidays are out of scope, (3) only regional
+  holidays."* Obvious-to-the-agent ≠ in-scope; `scope-control` owns the
+  expansion permission.
+
+## Precedence & subordination
+
+| Neighbour rule | Relationship |
+|---|---|
+| `ask-when-uncertain` | **Parent ask discipline.** This rule folds its discrepancy into that rule's single question. `ask-when-uncertain` fires on *missing* info; this adds *conflicting present* sources. Never a second question block. |
+| `scope-control` | **Permission authority** for the type-(b) silent-scope-expansion. This rule surfaces the expansion; `scope-control` gates it. |
+| `design-fidelity` | **Fires after** this rule. This rule resolves a text↔image conflict at decision time; `design-fidelity` then enforces build-time 1:1 fidelity to the resolved design. |
+| `source-discovery` / `source-discovery-gate` | **Owns verification** for type (c). This rule surfaces the spec↔code conflict; `source-discovery` provides the evidence procedure. |
+| `no-cheap-questions` | **Floor.** A discrepancy ask must carry a real trade-off; batch, never nag. |
+| `active-remediation` | **Sibling shape.** Its never-silently-ignore ladder is the response model this rule applies to source discrepancies rather than code issues. |
+
+## Failure modes
+
+- **Silent-correct-guess.** Picking the right reading of a contradiction without
+  asking. Correct output, wrong process — still a violation.
+- **Double-firing.** Emitting a discrepancy question AND a separate
+  `ask-when-uncertain` / `improve-before-implement` question about the same
+  underlying uncertainty. Fold into one turn's one question.
+- **Noise creep.** Surfacing plausible re-readings as if they were hard
+  contradictions. Use the confidence tier; `auto` states low-confidence as an
+  assumption instead of asking.
+- **Silent scope expansion.** Implementing an inferred-but-unspecified behavior
+  because it seems obvious. It is a scope decision the user owns.

package/docs/guidelines/component-oriented-and-oop-development.md

@@ -0,0 +1,181 @@
+# Component-Oriented & Object-Oriented Development
+
+> Cross-cutting development standard: **think in reusable units, and — in an
+> object-oriented / class-based codebase — treat object-oriented design as a
+> high-priority default where it reduces complexity.** Split by surface below
+> (frontend / backend), each pointing to the stack-specific carve-outs rather
+> than restating them. Framework-neutral by construction — React / Storybook /
+> Laravel / Symfony specifics live in their own skills, never here.
+
+## Paradigm-appropriate first — detect, then apply
+
+**Reuse is universal; OOP is paradigm-scoped.** Detect the codebase's paradigm
+before applying the object-oriented half: class-based / OO code (PHP, Java, C#,
+typical TS/React service layers) → this standard's OOP guidance is the
+high-priority default. A **functional / pipeline / actor-model** codebase
+(Elixir/Phoenix, Clojure, Haskell, Go-idiomatic, heavy FP-in-TS) → apply *that*
+paradigm's principles (immutability, pure functions, pattern-matching,
+composition of functions), and read the OOP bullets as "the same rigor, its
+paradigm's shape." **Never impose classes on functional code to satisfy this
+standard** — consistency with the codebase's chosen paradigm wins over OOP
+advocacy, always.
+
+## The standard, in one breath
+
+- **Reuse before you build** (every paradigm). Compose from units that already
+  exist — audit first, reuse the design system / shared abstractions, extract a
+  new unit only when the same shape repeats.
+- **Object-oriented where it fits** (in an OO codebase). Encapsulation, single
+  responsibility, composition over inheritance, and behavior-rich objects are
+  the high-priority default *when they reduce complexity* — not a quota to hit,
+  and not imposed on a codebase that has chosen a different paradigm.
+
+## The load-bearing caveat — reuse/OOP is a tool, never a mandate to abstract
+
+This standard **never** authorizes speculative abstraction. It is bounded by the
+package's restraint posture and defers to it on every conflict:
+
+- [`minimal-safe-diff`](../../src/rules/minimal-safe-diff.md) (+ its
+  anti-over-engineering mechanics) — smallest change; no premature abstraction,
+  no speculative feature, no rewrite for taste.
+- [`senior-engineering-discipline`](../../src/rules/senior-engineering-discipline.md)
+  — reuse the *existing* abstraction; generalize, don't overfit; never invent an
+  API to look object-oriented.
+- [`improve-before-implement`](../../src/rules/improve-before-implement.md) —
+  "does it fit the existing architecture?" before adding structure.
+- **When NOT to use a pattern** ([`php/patterns.md`](php/patterns.md) §) — KISS &
+  YAGNI trump pattern purity: no interface for a single implementation, no
+  pattern for a five-line function, no class where a function is clearer.
+
+Rule of thumb: **two real repetitions (or a genuine second axis of change)
+before you extract.** One occurrence is not a component; one branch is not a
+Strategy. A reviewer should be able to name the concrete duplication or the
+concrete change-axis the abstraction removes.
+
+**Precedence (explicit): `minimal-safe-diff` / YAGNI always trump OOP
+advocacy.** When "prefer OO shape" and "smallest change" conflict, the smallest
+change wins — this standard adds a *consideration*, never a competing objective
+that pressures preemptive abstraction. The review lens (below) may flag OO shape
+only where the duplication or the growing branch is **already present in the
+diff**, never as "this could grow later."
+
+## Frontend — think in reusable components
+
+Component-first is the default mindset, not an afterthought: decompose a screen
+into composable units, reuse the project's primitives, and extract shared shells
+when they repeat. Depth and mechanics already live in dedicated skills — consult
+them, don't duplicate:
+
+- [`fe-design`](../../src/skills/fe-design/SKILL.md) § Component Architecture —
+  the stack-agnostic "kind, not framework" taxonomy, granularity, extract-on-3+.
+- [`ui-component-architect`](../../src/skills/ui-component-architect/SKILL.md) —
+  how to *shape* a reusable component: composition over inheritance, slot
+  contracts, prop-API caps, controlled/uncontrolled, the componentization
+  threshold (repeat **and** real state).
+- [`existing-ui-audit`](../../src/skills/existing-ui-audit/SKILL.md) — the
+  reuse-before-invent gate: inventory existing components/tokens/primitives
+  first (enforced by [`ui-audit-gate`](../../src/rules/ui-audit-gate.md)).
+- [`design-tokens`](../../src/skills/design-tokens/SKILL.md) /
+  [`design-system-capture`](../../src/skills/design-system-capture/SKILL.md) —
+  the shared token/design-system layer components draw from.
+
+**Component workshop (Storybook et al.) — when the project is large enough.**
+For a project with a real, growing shared-component library, isolating and
+documenting each reusable component in a component workshop (Storybook or the
+ecosystem equivalent) pays for itself — it makes components discoverable,
+reviewable in isolation, and reused instead of re-invented. It is **not** worth
+the setup for a small surface with a handful of one-off components. The
+framework-specific setup is a carve-out, not a generic mandate — React /
+Storybook specifics: [`react-shadcn-ui`](../../src/skills/react-shadcn-ui/SKILL.md)
+§ Component workshop.
+
+Framework carve-outs (never restated here): React →
+[`react-shadcn-ui`](../../src/skills/react-shadcn-ui/SKILL.md); Next.js
+server/client component boundary →
+[`nextjs-patterns`](../../src/skills/nextjs-patterns/SKILL.md); Laravel FE →
+[`blade-ui`](../../src/skills/blade-ui/SKILL.md) /
+[`livewire`](../../src/skills/livewire/SKILL.md) /
+[`flux`](../../src/skills/flux/SKILL.md); styling →
+[`tailwind-engineer`](../../src/skills/tailwind-engineer/SKILL.md).
+
+## Backend — object-oriented where it reduces complexity
+
+The structural half — thin handlers, business logic in services / use-cases,
+behavior-rich domain models, validation at the boundary — is owned by
+[`architecture`](../../src/rules/architecture.md) and holds across paradigms. In
+an **object-oriented / class-based** service layer, layer the OO principles below
+on top of it, each applied only where it earns its place. In a **functional /
+pipeline** codebase, apply that paradigm's equivalent (pure functions +
+composition instead of behavior-rich objects; a dispatch map / pattern-match
+instead of a Strategy class) — the goal (encapsulate change, one responsibility,
+compose don't duplicate) is paradigm-independent; only its *shape* is OO here:
+
+- **Encapsulation** — objects own their data + the behavior over it; no anemic
+  bags mutated from the outside.
+- **Single responsibility** — one class, one reason to change; no god services.
+- **Composition over inheritance** — inject collaborators; reach for a base
+  class only for genuine is-a substitutability, not code sharing.
+- **Behavior-rich domain objects** — push rules into the model, keep services
+  orchestration-thin.
+- **Patterns where they earn their place** — a Strategy when a branch on a
+  discriminator will grow (`if-else` chain → polymorphism); a Factory when
+  construction is non-trivial; DI on an abstraction when there is a *real*
+  second implementation. Not before.
+
+Language / framework carve-outs (never restated here): PHP →
+[`php-coding-patterns`](php/php-coding-patterns.md) +
+[`patterns.md`](php/patterns.md) (+ `patterns/strategy.md`,
+`patterns/dependency-injection.md`, `patterns/factory.md`, `patterns/service-layer.md`)
++ skills [`php-coder`](../../src/skills/php-coder/SKILL.md) /
+[`php-service`](../../src/skills/php-service/SKILL.md); Laravel →
+[`laravel`](../../src/skills/laravel/SKILL.md); Symfony →
+[`symfony-workflow`](../../src/skills/symfony-workflow/SKILL.md); Next.js / TS →
+[`nextjs-patterns`](../../src/skills/nextjs-patterns/SKILL.md); cross-language
+clean-code baseline → [`code-clarity`](code-clarity.md).
+
+## Enums over scattered literals
+
+A field with two or more non-boolean states is an enum, not a bare string /
+magic number — the small OO move that keeps a codebase greppable and safe to
+change. Full rule + the defer-and-ask flow for pre-existing literals:
+[`prefer-enums-over-literals`](../../src/rules/prefer-enums-over-literals.md).
+
+## How this is reviewed
+
+"Reuse existing components + object-oriented shape (where it reduces
+complexity)" is a check on the code-quality review lens
+([`judge-code-quality`](../../src/skills/judge-code-quality/SKILL.md)), so it
+reaches `/review-changes`, `/judge`, the subagent judge modes, and team-mode's
+fallback review frame. It fires **only where the duplication or the growing
+branch is already present in the diff** — never "this could grow later" — and
+in the **codebase's own paradigm** (it will not tell a functional service to
+grow a class). It stays a human-judgment call that defers to the codebase's own
+conventions — never a generic SOLID dogma imposed over a project that has chosen
+differently.
+
+## Council review (2026-07-15)
+
+Deep debate, 3 rounds, cross-vendor (`anthropic/claude-sonnet-4-5` +
+`openai/gpt-4o`), $0.16. Split verdict; the load-bearing (anthropic) critique —
+that an "OOP-supreme default" over-indexes on OOP for a multi-paradigm consumer
+base and can conflict with `minimal-safe-diff` — was applied, bounded by this
+standard's stated purpose (OOP *is* a deliberate high priority for the operator):
+
+- **Paradigm-appropriate framing** — OOP is the high-priority default *within an
+  OO / class-based codebase*; detect and defer to a functional / pipeline /
+  actor paradigm; never impose classes on functional code (§ Paradigm-appropriate).
+- **Explicit precedence** — `minimal-safe-diff` / YAGNI win on conflict; the
+  review lens flags only *already-present* duplication / complexity, never
+  preemptive (§ caveat, § How this is reviewed).
+
+Divergence held: the frontend section stays (an intentional FE / backend
+entry-point + carve-out index, per the operator's explicit "split by FE /
+backend" ask) — against the anthropic "delete as redundant"; it is a cohesive
+index of the existing FE surfaces, not a claim of novel guidance. Trace:
+`agents/runtime/council/responses/component-oop-standard.json/` (gitignored, local-only).
+
+## See also
+
+- [`architecture`](../../src/rules/architecture.md) — the structural home this layers onto.
+- [`code-clarity`](code-clarity.md) — the cross-language clean-code baseline.
+- [`minimal-safe-diff`](../../src/rules/minimal-safe-diff.md) · [`senior-engineering-discipline`](../../src/rules/senior-engineering-discipline.md) — the restraint anchors this standard is bounded by.

package/docs/proof.md

@@ -27,7 +27,7 @@ evidence pointer, or `task check-claims` fails the build.
 | Claim | Kind | Evidence | Resolves |
 |---|---|---|---|
 | 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` | ✅ |
-| 184 commands. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
+| 189 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` | ✅ |
@@ -41,11 +41,11 @@ evidence pointer, or `task check-claims` fails the build.
 | The whole layer is compiled into host agents with zero runtime daemon. | qual | `docs/contracts/no-runtime-boundary.md#file-first, no-runtime suite` | ✅ |
 | On a 12-fixture option-decision corpus (3 arms × 2 providers, blind rubric judge claude-opus-4-8, pre-registered hypotheses), famous-figure identity framing added nothing beyond the underlying method text (method 5.04 vs figure 4.88, Δ=0.17, sign-test p=0.607), and provider diversity moved judged quality ~15× more than persona identity (provider Δ=2.58 vs identity Δ=0.17); the whole persona layer lifted only +0.08 over bare prompts. Honest null — persona panel-mode stays CUT, evidence-closed. | quant | `internal/bench/reports/persona-placebo.json#honest-null` | ✅ |
 | On the live end-to-end retrieval benchmark (9 tasks × 3 arms × 3 seeds on claude-haiku, fixture store with keyword-overlapping confusers), the memory retrieval substrate scored precision@5 = 100% (9/9) with 100% poisoned-entry rejection, and the retrieval-on arm passed 27/27 model-scored tasks vs 2/27 with retrieval off and 4/27 with a placebo injection. Known limit stays published: mean tie-set 4.1 means top-k ties break by store order, not relevance (the ADR-116/FTS5 signal). | quant | `internal/bench/reports/second-brain-retrieval.json#retrieval-on` | ✅ |
-| 104 governed rules. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
+| 105 governed rules. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
 | 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` | ✅ |
-| 275 skills. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
+| 276 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` | ✅ |
 
 **21 backed claim(s)** — all evidence pointers resolve in CI.
@@ -56,7 +56,7 @@ guidelines, personas) are **generated from source and CI-drift-checked**:
 fails the build on any count-shaped prose mention that drifts from the
 source count — or on two different numbers for the same artefact kind.
 
-We also publish our **debt**: 4 claim(s) are logged as
+We also publish our **debt**: 5 claim(s) are logged as
 `unbacked` inventory in the ledger — not yet bound, and therefore not
 allowed to carry a marker in public prose. Hiding them would be the
 opposite of the point.
@@ -77,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 **42 of 275** skills carry a behavioural
+as good as its measurement. Today **42 of 276** 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
-(7 of 240) is not. We publish that gap rather than imply
-"275 evaluated skills": coverage is measured per tier
+(7 of 241) is not. We publish that gap rather than imply
+"276 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": "9.1.0",
+    "version": "9.3.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,
@@ -70,7 +70,8 @@
         "lint:ts": "eslint 'src/**/*.ts'",
         "test:ts": "vitest run",
         "prepack": "npm run build && npm run build:discovery && npm run build:mcp-manifest && node src/scripts/prepack-check.mjs",
-        "prepublishOnly": "./scripts-run src/scripts/check_release_includes_discovery"
+        "prepublishOnly": "./scripts-run src/scripts/check_release_includes_discovery",
+        "prepare": "[ -d .git ] && bash src/scripts/install-hooks.sh || true"
     },
     "publishConfig": {
         "access": "public",

package/src/config/agent-settings.template.yml

@@ -518,6 +518,34 @@ design:
   #              autonomy setting, roadmap, or standing instruction lifts it).
   fidelity_mode: strict
 
+# --- Cross-source consistency ---
+#
+# When the agent plans, refines, roadmaps, or implements from multiple
+# sources — ticket text, an attached image / mockup / screenshot, the spec,
+# the codebase — it actively checks them AGAINST each other and STOPS to ask
+# before proceeding on a detected discrepancy, instead of silently guessing
+# (even a correct guess). Consumed by the `cross-source-consistency` rule.
+# Catches: (a) ticket text vs an attached image/mockup, (b) a spec silent on
+# a clearly-needed behavior (weekend/holiday shifting, empty/error states),
+# (c) spec vs the codebase, (d) intra-ticket contradiction (AC vs description).
+#
+# The discipline is deliberately subordinate to `ask-when-uncertain` (it folds
+# a detected discrepancy into the same turn's single question — never a second
+# prompt) and defers to `scope-control` for the permission to expand scope.
+consistency:
+  # on | auto | off  (default: on)
+  #
+  # on   = default. Detect discrepancies across sources and surface ONE
+  #        numbered-options question before proceeding. A silent guess on a
+  #        real contradiction is a rule violation, even when the guess is
+  #        correct. An inferred-but-unspecified behavior is a scope expansion:
+  #        ask before implementing it.
+  # auto = detect + surface only HIGH-confidence contradictions; low-confidence
+  #        ones are stated as an assumption and proceed (noise control).
+  # off  = no cross-source checking (legacy: the agent may proceed on its own
+  #        reading of whichever source it happened to read).
+  cross_source: "on"
+
 code_style:
   # minimal | full  (default: minimal)
   #
@@ -604,6 +632,20 @@ subagents:
   # Integer, default 3. Set to 1 to serialize. Hard cap enforced by runtime.
   max_parallel: 3
 
+  # Opt-in adversarial-verification-council (subagent-orchestration Mode 9,
+  # ADR-122):  off | ask | on
+  #
+  # off (default) = never runs. ask = offer it on an explicit high-risk change.
+  # on = auto-run on high-risk changes (security, tenant, migration, public API).
+  #
+  # A panel of distinct-model skeptics red-teams a real, already-verified change
+  # for defect FINDING coverage (not a go/no-go decision) and returns an advisory
+  # findings-by-severity verdict. ADVISORY ONLY — it NEVER auto-gates the change
+  # (Hard Floor). The registered claim + high-risk tier use cross-vendor skeptics.
+  # Stays default-off until the adversarial-council-finding-coverage claim is
+  # backed by the two-stage residual-detection benchmark (prove-or-drop).
+  adversarial_council: off
+
 # --- Git worktrees ---
 #
 # Controls how the `using-git-worktrees` skill and `subagent-orchestration`