@event4u/agent-config 9.8.0 → 9.10.0

package/dist/agent-src/skills/standards-from-config/SKILL.md

@@ -11,76 +11,94 @@ packs:
 
 # standards-from-config
 
-Evidence v2 **Class A** — configured convention. Coding standards are not *guessed*
-and not *observed* — **derived from the real tooling config**. The config *is* the
-standard; this skill produces a **pointer + digest**, never a flattened claim.
-High-trust, auto-refreshable, drift-proof.
+Evidence v2 **Class A** — configured convention. The safe, on-thesis half of
+self-building project context: coding standards are not *guessed* and not
+*observed*, they are **derived from the real tooling config**. The config *is*
+the standard; this skill produces a **pointer + digest**, never a flattened
+claim. High-trust, auto-refreshable, drift-proof — because the truth lives in
+the config file, and the card only points at it plus distils the 3–5 points an
+agent needs most while writing.
 
 Definitions (Class A/B/C, trust tiers, the v1↔v2 isolation contract) live in
 [`evidence-discipline`](../../agent-src/contexts/execution/evidence-discipline.md);
-parent context mechanism is [`context-document`](../context-document/SKILL.md).
+the parent context mechanism is [`context-document`](../context-document/SKILL.md).
 
 ## When to use
 
-- Before writing or reformatting code in an unfamiliar project — need enforced style.
-- Before writing a commit message / branch name — need project's commit convention.
+- Before writing or reformatting code in an unfamiliar project and you need its
+  enforced style (indent, line length, quote style, import order, naming).
+- Before writing a commit message / branch name and you need the project's
+  commit convention.
 - When orienting in a repo and a committed Class-A standards card would save the
   next agent from re-deriving the same config.
 
-Do NOT use for: a standard with **no** config backing (that's Class B or nothing —
-never invent a Class-A claim); concrete shape of code (that's v1 `source-discovery`,
-read fresh); project with no tooling config (record a negative fact).
+Do NOT use for: a standard that has **no** config backing (that is a *guessed*
+or *observed* convention — Class B, not A; never invent a Class-A claim); the
+concrete shape of code (that is v1 `source-discovery`, read fresh); a project
+with no tooling config at all (record a negative fact: "no enforced standard
+found", do not fabricate one).
 
 ## Procedure
 
-1. **Detect real config sources** (read fresh, never from memory). By ecosystem — inspect
-   what actually exists:
-   - cross-stack: `.editorconfig`, `CONTRIBUTING.md`, commitlint / `.gitmessage`, CI lint steps.
-   - JS/TS: `eslint.config.js` / `.eslintrc*`, `.prettierrc*`, `biome.json`, `tsconfig.json`.
+1. **Detect the real config sources** (read fresh, never from memory). Common
+   sources, by ecosystem — inspect what actually exists:
+   - cross-stack: `.editorconfig`, `CONTRIBUTING.md`, commitlint /
+     `.gitmessage`, the lint/format steps in the CI workflow.
+   - JS/TS: `eslint.config.js` / `.eslintrc*`, `.prettierrc*`, `biome.json`,
+     `tsconfig.json` (strictness).
    - PHP: `pint.json`, `.php-cs-fixer.dist.php`, `phpcs.xml`.
-   - Python: `pyproject.toml` / `ruff.toml` (`[tool.ruff]`, `[tool.black]`), `setup.cfg`.
+   - Python: `pyproject.toml` / `ruff.toml` (`[tool.ruff]`, `[tool.black]`),
+     `setup.cfg`.
    - Ruby: `.rubocop.yml`. Go: `gofmt`/`golangci.yml`.
-2. **Derive as pointer + digest, never a flattened claim.** Each standard is one line:
-   the **value**, the **config file it came from**, and the **scope**. Write
-   `ruff.toml → line-length = 88 (scope: src/**/*.py)`, NOT "the project uses line
-   length 88". The pointer makes the claim re-checkable.
-3. **Preserve scope; surface conflicts, never flatten them.** Two configs or an inline
-   override disagree → emit **two pointers with two values + their scopes** — never
-   one ambiguous merged claim. A visible conflict is correct.
+2. **Derive as pointer + digest, never a flattened claim.** Each standard is one
+   line: the **value**, the **config file it came from**, and the **scope** it
+   applies to. Write `ruff.toml → line-length = 88 (scope: src/**/*.py)`, NOT
+   "the project uses line length 88". The pointer makes the claim re-checkable
+   and the next agent can open the config to confirm.
+3. **Preserve scope; surface conflicts, never flatten them.** If two configs (or
+   an inline / per-directory override) give two values, emit **two pointers with
+   two values + their scopes** — never one ambiguous merged claim. A visible
+   conflict is correct; a hidden flattened guess is the failure mode.
 4. **Stamp staleness.** Record each source's `config_mtime` (or content hash).
-   Digest is stale when config file's mtime/hash changes → re-derive. No human gate
-   needed (Class A is deterministic) — digest **regenerated from config, never
-   hand-edited**.
-5. **Persist** as a Class-A context card under `agents/settings/contexts/`. Class A is
-   high-trust *because* config-derived — read for heuristics only, never bypasses a
-   fresh structural read (v1↔v2 isolation contract).
+   The digest is stale when the config file's mtime/hash changes → re-derive. No
+   human gate is needed (Class A is deterministic) — the digest is **regenerated
+   from the config, never hand-edited**.
+5. **Persist** as a Class-A context card under `agents/settings/contexts/` (see
+   Output format). Class A is high-trust *because* config-derived — it is read
+   for heuristics only and never bypasses a fresh structural read (the v1↔v2
+   isolation contract in `evidence-discipline`).
 
 ## Output format
 
 A Class-A standards card MUST contain, in order:
 
-1. **Frontmatter** `class: A`, `trust: high (config-derived)`, and a `sources:` list
-   of `{path, config_mtime}` for every config the digest reads.
+1. **Frontmatter** `class: A`, `trust: high (config-derived)`, and a
+   `sources:` list of `{path, config_mtime}` for every config the digest reads.
 2. **A pointer+digest table** — one row per standard: `standard | value | source
-   (file:key) | scope`. No standard appears without a `source` cell.
-3. **A conflicts block** (may be empty) — any standard where ≥2 sources/scopes
-   disagree, as two-or-more rows, never one merged value.
-4. **A refresh line** — card is regenerated when any listed `config_mtime` changes;
-   read for heuristics only (never a structural bypass).
+   (file:key) | scope`. No standard appears without a `source` cell pointing at
+   a real config file.
+3. **A conflicts block** (may be empty) listing any standard where ≥2 sources /
+   scopes disagree, as two-or-more rows, never one merged value.
+4. **A refresh line** stating the card is regenerated when any listed
+   `config_mtime` changes, and is read for heuristics only (never a structural
+   bypass).
 
 ## Gotcha
 
-- A standard with no config backing is **not** Class A — do not write it here; it is
-  Class B (observed) or nothing. Class A never fabricates.
-- Do not flatten conflicting configs into one value — the conflict is the signal.
-- Card is a **regenerated digest**, not a hand-edited doc — editing the value by hand
-  defeats drift-proofing.
+- A standard with no config backing is **not** Class A — do not write it here;
+  it is a guessed/observed convention (Class B) or nothing. Class A never
+  fabricates.
+- Do not flatten conflicting configs into one value — the conflict is the
+  signal; surface both pointers.
+- The card is a **regenerated digest**, not a hand-edited doc — editing the
+  value by hand instead of the config defeats the drift-proofing.
 - A green pointer is not "the code obeys this" — it means the config declares it;
-  whether a given file complies is a fresh read.
+  whether a given file complies is a fresh read, not this card's claim.
 
 ## Do NOT
 
-- Do NOT emit a coding standard as a believed fact — emit a pointer to the config.
+- Do NOT emit a coding standard as a believed fact ("we use 4 spaces") — emit a
+  pointer to the config that declares it.
 - Do NOT merge conflicting configs into a single claim.
 - Do NOT hand-edit the digest value instead of the config.
 - Do NOT use a Class-A card to skip a fresh structural read (v1 stays in force).
@@ -89,5 +107,5 @@ A Class-A standards card MUST contain, in order:
 ## See also
 
 - [`evidence-discipline`](../../agent-src/contexts/execution/evidence-discipline.md) — Class A/B/C, trust tiers, the isolation contract.
-- [`context-document`](../context-document/SKILL.md) — parent context mechanism + storage locations.
+- [`context-document`](../context-document/SKILL.md) — the parent context mechanism + storage locations.
 - [`source-discovery`](../source-discovery/SKILL.md) — v1 structural discovery (read fresh; Class A never bypasses it).

package/dist/agent-src/skills/subagent-orchestration/SKILL.md

@@ -107,10 +107,33 @@ Rules:
   size floor) — it never re-interprets the task text on vibes.
 - Ambiguous shape → `none` (in-session), never a speculative spawn — the
   delegation-policy default.
+- **Fork vs. named subagent — an ordering, never a default (road-to-cache-economy
+  Phase 4).** On a host that offers a fork primitive, decide fork-vs-named
+  ORTHOGONALLY to the form picked above: tool and scope fit is first-order,
+  cache inheritance is second-order. A fork is preferred only when the child
+  continues the parent's task under identical tools and constraints (it then
+  reads the parent's cache on its first request); a named subagent is
+  preferred the moment isolation, a different tool set, or nested dispatch is
+  needed — a fork cannot nest, and forking forces background mode, which
+  changes the tool set and invalidates the very prefix that motivated the
+  fork. `do-in-parallel`-shaped fan-out from one parent has this shape by
+  construction (a known, unfixable upstream cost — see
+  [`prompts/README.md`](prompts/README.md) § Prompt-cache discipline). NEVER
+  encode "always fork" — that was proposed and cut (council 2026-07-30):
+  the cache-sharing benefit cannot be predicted before the fork happens.
 - Record the outcome in the telemetry line (`dispatch_mode` field, mode id
   or `none`) so the gate's value is measurable inside the ADR-117
   prove-or-drop window.
 
+## Severity-conditioned team composition — conditions pattern
+
+Incident-style severity tiers (Critical / High / Medium / Low) refine
+composition and activation **within** the form the static gate already
+picked — severity never overrides the form gate, the Iron Law, or any
+safety floor. Guidance, not a new object class (persona-catalog
+disposition). Severity→composition table + escalation rule →
+[`subagent-modes-detail` § Severity-conditioned team composition](../../agent-src/contexts/execution/subagent-modes-detail.md).
+
 ## The nine modes
 
 Each mode has a decision row: when to use, when not, and the expected
@@ -124,42 +147,23 @@ glossary) lives in
 [`subagent-topologies`](../../agent-src/contexts/execution/subagent-topologies.md) —
 pull it for capacity planning; it is metadata, not runtime-enforced.
 
+Per-mode decision rows (when to use / when not / model pairing) and the
+mode-2 stage-routing contract live in
+[`subagent-modes-detail` § Modes 1–6](../../agent-src/contexts/execution/subagent-modes-detail.md) —
+pull them at dispatch time.
+
 ### 1. do-and-judge
 
 Implementer produces a diff; judge reviews; loop applies, revises, or
 hands off. Hard ceiling: **two revision cycles**, then stop and hand
 back to the user.
 
-| When to use | When not | Model pairing |
-|---|---|---|
-| Single-change task with non-trivial risk | Tiny fix, or spike/exploration | implementer = session; judge = one tier up |
-
 ### 2. do-and-judge-two-stage
 
-Implementer produces a diff; **two judges run sequentially** — first a
-spec-compliance reviewer (does the diff satisfy the stated spec /
-acceptance criteria?), then a code-quality reviewer (is the diff well-
-written for the codebase it lands in?). The orchestrator only proceeds
-to stage two if stage one returns `DONE` or `DONE_WITH_CONCERNS`. A
-stage-one `BLOCKED` shortcuts the loop — there is no point quality-
-reviewing a diff that does not satisfy the spec.
-
-| When to use | When not | Model pairing |
-|---|---|---|
-| Spec is contested or AC are detailed; diff size makes one judge prone to missing one axis (correctness vs craft) | Spec is one sentence, or the diff is one line (collapse to mode 1) | implementer = session; spec-judge = one tier up; quality-judge = same tier as spec-judge, fresh context |
-
-**Why two stages, not one judge with both rubrics:** combining the
-rubrics in one prompt reliably regresses one of them — the judge "spends
-attention" on whichever rubric appears last. Splitting the prompts
-forces each judge to commit fully to its rubric.
-
-**Stage-routing rule:**
-- Stage-1 returns `DONE` → run stage-2.
-- Stage-1 returns `DONE_WITH_CONCERNS` → run stage-2; concerns carry
-  forward to the final envelope.
-- Stage-1 returns `NEEDS_CONTEXT` → pause; stage-2 does not run.
-- Stage-1 returns `BLOCKED` → final verdict is `BLOCKED`; stage-2
-  does not run (saves cost).
+Implementer produces a diff; **two judges run sequentially** — spec
+compliance first, code quality second. Stage-one `BLOCKED` shortcuts the
+loop (no point quality-reviewing a diff that misses the spec). Stage
+routing + why-two-stages rationale → modes-detail § Mode 2.
 
 ### 3. do-in-steps
 
@@ -167,40 +171,24 @@ Plan is split into N steps; judge runs **between** steps. A step that
 fails judgment is revised before the next step starts. Used for
 multi-file changes where a mid-plan mistake would cascade.
 
-| When to use | When not | Model pairing |
-|---|---|---|
-| Multi-step plan with ordered dependencies | Single-step change, or when steps are independent (use `do-in-parallel`) | implementer = session; judge = one tier up |
-
 ### 4. do-in-parallel
 
 Independent slices run concurrently. No judge per slice — judge runs
 once on the aggregated result. Parallelism capped by
 `subagents.max_parallel` in `.agent-settings.yml`.
 
-| When to use | When not | Model pairing |
-|---|---|---|
-| Independent slices (different files, non-overlapping) | Any slice touches shared state | implementer = session; judge = one tier up, run once |
-
 ### 5. do-competitively
 
 Multiple implementers produce candidate diffs for the **same** slice.
 Judge picks the winner and rejects the losers. Expensive — use only
 when the solution space is genuinely broad.
 
-| When to use | When not | Model pairing |
-|---|---|---|
-| Broad solution space (algorithm choice, API shape) | Well-defined problem with one good answer | implementers = same tier (≥2 instances); judge = one tier up |
-
 ### 6. judge-with-debate
 
 Two judges each produce a verdict; a meta-judge reconciles
 disagreements. Used for high-stakes changes (security, data
 migration, public API) where a single judge is too easy to fool.
 
-| When to use | When not | Model pairing |
-|---|---|---|
-| Security, data integrity, public API change | Routine internal refactor | judges = same tier (2x); meta-judge = one tier up |
-
 Mode 6 = **go/no-go** (strict-er verdict wins); for defect-FINDING coverage (the
 *union* of what diverse models catch) use Mode 9.
 
@@ -238,34 +226,25 @@ opt-in high-risk changes only; registered claim + high-risk tier need
 cross-*vendor* skeptics. Invariants, skeptic prompt, reconciliation, prove-or-drop
 gate → [`subagent-modes-detail`](../../agent-src/contexts/execution/subagent-modes-detail.md) § Mode 9
 + [`prompts/adversarial-verification-council.md`](prompts/adversarial-verification-council.md)
+
+> **Disposition (2026-07-28, honest null).** The adversarial-council finding-
+> coverage benchmark resolved as a published null (see `docs/benchmark.md`) —
+> this mode is NOT sold as a defect-detection capability. It stays default-off
+> bound to that null; scheduled for removal at the next major unless external
+> evidence (a consumer-filed case where the panel surfaced a real defect the
+> single verifier missed) appears first. Its remaining honest value is
+> perspective diversity + decision documentation, nothing more.
 (ADR-122).
 
 ## Status taxonomy — every subagent return uses one envelope
 
 Every implementer or judge return must conform to
-[`schemas/subagent-status.json`](schemas/subagent-status.json). Four
-statuses, no free-form alternatives:
-
-| Status | Meaning | Required keys (beyond `status`, `summary`) |
-|---|---|---|
-| `DONE` | Work shipped, all gates green. | `evidence[]` |
-| `DONE_WITH_CONCERNS` | Work shipped but caller must act on concerns. | `evidence[]`, `concerns[]` |
-| `NEEDS_CONTEXT` | Paused; caller can unblock by answering. | `blocking_question` |
-| `BLOCKED` | No path forward exists. | `blocking_reason` |
-
-**Why a fixed taxonomy:** orchestrators (`/do-and-judge`, `/do-in-steps`)
-route on status. Free-form "kind of done" returns force the orchestrator
-to interpret prose, which silently regresses the two-revision ceiling and
-the judge-rejected-do-not-apply rule. The schema makes routing mechanical.
-
-**Tests:** `tests/test_subagent_status_schema.py` exercises all four
-statuses plus rejection cases (missing required keys, unknown status,
-extra fields, conditional-key violations).
-
-**Distinguishing `NEEDS_CONTEXT` from `BLOCKED`:** `NEEDS_CONTEXT` means
-*"you, the caller, can fix this by telling me X"*. `BLOCKED` means
-*"no input from you unblocks this — escalate or rescope"*. If a subagent
-is unsure, it picks `BLOCKED` and the caller can downgrade.
+[`schemas/subagent-status.json`](schemas/subagent-status.json). Exactly
+four statuses — `DONE` · `DONE_WITH_CONCERNS` · `NEEDS_CONTEXT` ·
+`BLOCKED` — no free-form alternatives; orchestrators route on status
+mechanically. Meaning/required-keys table, why-fixed rationale, and the
+`NEEDS_CONTEXT`-vs-`BLOCKED` distinction →
+[`subagent-modes-detail` § Status taxonomy](../../agent-src/contexts/execution/subagent-modes-detail.md).
 
 ## Dispatch prompts — externalized
 
@@ -273,9 +252,12 @@ Each mode's literal dispatch template lives under
 [`prompts/{mode}.md`](prompts/README.md). The orchestrator loads the
 matching prompt at dispatch time and substitutes `{{placeholders}}`.
 Edits to a prompt do not bloat this skill against the 400-line sunset
-trigger; `tests/test_subagent_prompt_loading.py` confirms each of the
-nine modes resolves to a loadable prompt that cites all four taxonomy
-statuses.
+trigger. Eight prompt files cover modes 1–7 and 9 (the standalone judge
+reuses [`prompts/do-and-judge.md`](prompts/do-and-judge.md); mode 8's
+live-app rubric lives in
+[`subagent-modes-detail` § Mode 8](../../agent-src/contexts/execution/subagent-modes-detail.md));
+each prompt cites all four taxonomy statuses — see
+[`prompts/README.md`](prompts/README.md).
 
 ## Procedure
 
@@ -339,21 +321,13 @@ the judge verdict.
 
 ### 6. Emit telemetry
 
-After every auto-dispatched run, write one telemetry line to
-`agents/runtime/state/audit/YYYY-MM.jsonl` (current UTC month — use
-`new Date().toISOString().slice(0, 7)` to compute the filename).
-The line is a standard audit-log-v1 object with `input_kind:
-"orchestration"` and an `orchestration` sub-object per
-[`orchestration-telemetry.md`](../../agent-src/contexts/execution/orchestration-telemetry.md).
-
-Minimal emit (fill what is observable; `token_delta_provenance: "estimated"` if
-host usage metadata is unavailable):
-
-```json
-{"schema_version":1,"id":"<ulid>","ts":"<iso>","work_id":"<work_id>","phase":"implement","outcome":"success","confidence_band":"high","risk_class":"low","input_kind":"orchestration","type":"phase","orchestration":{"task_size_estimate":<int>,"spawn_count":<int>,"tiers":[...],"token_delta":<int>,"token_delta_provenance":"estimated","wall_clock_ms":<int>,"outcome":"DONE","verify_mode":"deterministic"}}
-```
-
-Skip emit when `subagents.enabled: false` or `spawn_count == 0` (in-session run).
+After every auto-dispatched run, write one audit-log-v1 line
+(`input_kind: "orchestration"`) via the `orchestration_record` recorder —
+never hand-author the JSON. Line shape, field semantics, recorder
+invocation, and `token_delta` sourcing priority →
+[`orchestration-telemetry` § Emit procedure](../../agent-src/contexts/execution/orchestration-telemetry.md).
+Skip emit when `subagents.enabled: false` or `spawn_count == 0`
+(in-session run).
 
 ## Gotcha
 
@@ -395,6 +369,6 @@ Skip emit when `subagents.enabled: false` or `spawn_count == 0` (in-session run)
 | Stepwise plan with judge gates       | Inline — see [`prompts/do-in-steps.md`](prompts/do-in-steps.md) |
 | Standalone judge on an existing diff | Inline — see judge prompt in [`prompts/do-and-judge.md`](prompts/do-and-judge.md) |
 | External / networked second opinion  | [`ai-council`](../ai-council/SKILL.md) |
-| Cross-model review WITH repo access   | [`/team`](../../commands/team.md) (collaborative; subagents are in-session same-weights) |
+| Cross-model review WITH repo access   | [`/team`](../../domains/meta/team/command.md) (collaborative; subagents are in-session same-weights) |
 | Verifying completeness               | [`verify-before-complete`](../verify-before-complete/SKILL.md) |
 | What a subagent owns vs never owns   | [`subagent-boundary`](../../../docs/contracts/subagent-boundary.md) |

package/dist/agent-src/skills/subagent-orchestration/prompts/README.md

@@ -21,12 +21,15 @@ skill above the 400-line sunset trigger.
 Every prompt cites the status taxonomy in
 [`../schemas/subagent-status.json`](../schemas/subagent-status.json) and
 ends with the **return-envelope** instruction so the subagent's reply
-validates against `tests/test_subagent_status_schema.py`.
+validates against that schema.
 
 ## Prompt-cache discipline
 
 When dispatching sibling subagents (e.g. `do-in-parallel` with N independent
-slices), **reuse a stable system-prompt prefix** across all siblings. Keep
+slices), **reuse a stable dispatch-prompt prefix** across all siblings. On
+this host the **system prompt comes from the agent definition**, not from
+anything the orchestrator writes — the dispatch prompt (the templated user
+message below) is the one prefix the orchestrator actually controls. Keep
 task-invariant text (role declaration, constraints, status enum, return-envelope
 instruction) in the prefix; put only the slice-specific `TASK:` and
 `CONTEXT FILES:` in the variable section. This maximises host-side prompt-cache
@@ -43,10 +46,34 @@ instead of a read, and the prefix must be re-hit within the **5-minute TTL**, so
 dispatch siblings promptly rather than trickling them. This is why the win is
 real for **fan-out** (many siblings, one prefix) and marginal for one-shot
 dispatch. Verify a cohort is actually reading, not re-writing, by checking
-`usage.cache_read_input_tokens > 0` on the 2nd+ sibling.
+`usage.cache_read_input_tokens > 0` on the 2nd+ sibling. Measured effect
+(anthropics/claude-code#74318): same-type sibling prefix hits reach **85%**
+within a 5-minute window vs **45%** for a mismatched or trickled cohort.
+
+**Sibling-uniformity rules** (follow from cache partitioning — the cache key
+includes model and tool set, and any mismatch fragments the cohort's shared
+prefix into separate caches): dispatch a cohort with the **same model**, the
+same `effort`, and the **same tool set** across every sibling, and fire them
+**promptly** rather than trickling dispatches one at a time — a sibling
+dispatched after the 5-minute window has already closed pays the full write
+premium alone, gaining nothing from the cohort.
+
+**Fork vs. named subagent — an ordering, not a default.** Tool and scope fit
+is first-order; cache inheritance is second-order. Prefer a **fork** when the
+child continues the parent's task under identical tools and constraints (a
+fork inherits the parent's system prompt, tools, and conversation history
+exactly, so its first request reads the parent's cache). Prefer a **named
+subagent** when the child needs isolation, a different tool set, or nested
+dispatch — a fork cannot nest, and forking forces background mode, which
+changes the tool set and therefore invalidates the very prefix that
+motivated the fork in the first place. Never default to "always fork": that
+option was considered and cut ([`../SKILL.md`](../SKILL.md) § Form gate)
+precisely because the cache-sharing benefit cannot be predicted before the
+fork happens, and background mode can erase it outright.
 
 ## Loading
 
-`tests/test_subagent_prompt_loading.py` asserts that every mode named
-in `SKILL.md` § *The nine modes* has a loadable prompt file under this
-directory and that each prompt mentions all four status enum values.
+Every dispatchable mode named in `SKILL.md` § *The nine modes* maps to a
+prompt file in the table above (mode 8 is gated/experimental — its
+live-app rubric lives in the `subagent-modes-detail` context, not here);
+each prompt mentions all four status enum values.

package/dist/agent-src/skills/supply-chain-intake/SKILL.md

@@ -11,16 +11,16 @@ packs:
 
 # supply-chain-intake
 
-An LLM generates a plausible-sounding package name token-by-token with no lookup against a real registry. ~19.7% of AI-recommended packages don't exist (576k-sample study); the same fake name recurs across runs, so attackers pre-register it as malware — "slopsquatting". The `huggingface-cli` PoC (an empty package matching a common hallucination) drew 30k+ downloads. Endor Labs: only ~1 in 5 AI-recommended dependency versions is both real *and* safe. A dependency the agent named is untrusted until verified — never install it just because the model produced the name.
+An LLM generates a plausible-sounding package name token-by-token with no lookup against a real registry. ~19.7% of AI-recommended packages do not exist (576k-sample study); the same fake name recurs across runs, so attackers pre-register it as malware — "slopsquatting". The `huggingface-cli` proof-of-concept (an empty package matching a common hallucination) drew 30k+ downloads. Endor Labs: only ~1 in 5 AI-recommended dependency versions is both real *and* safe. A dependency the agent named is untrusted until verified — never install it just because the model produced the name.
 
 ## When to use
 
 - About to add a dependency to `package.json` / `requirements.txt` / `go.mod` / `Cargo.toml` / `composer.json` / `pyproject.toml`, or run `npm/pnpm/yarn install`, `pip install`, `go get`, `cargo add`, `composer require`.
-- Reviewing an AI-authored diff touching a dependency manifest or lockfile.
-- An install command was suggested (especially `curl … | bash`).
+- Reviewing an AI-authored diff that touches a dependency manifest or lockfile.
+- An install command was suggested (especially a `curl … | bash` one-liner).
 - About to add or connect an **MCP server** (an `npx`/`uvx`-launched package or a remote endpoint) to the agent config (`.mcp.json` / equivalent) — an MCP server is a dependency plus a tool-grant, so it runs the intake gate too.
 
-Do NOT use when: no dependency is added and no manifest/lockfile is touched.
+Do NOT use when: no dependency is being added and no manifest/lockfile is touched.
 
 ## The Iron Law
 
@@ -32,16 +32,16 @@ PIN IT, LOCK IT, CVE-SCAN IT. NEVER PIPE A REMOTE SCRIPT STRAIGHT TO A SHELL.
 
 ## Procedure — intake gate (run in order before adding a dependency)
 
-1. **Existence** — confirm the exact string resolves on the real registry, published before your session, with real usage:
+1. **Existence** — confirm the exact string resolves on the real registry, published before your session and with real usage:
    ```bash
    npm view <pkg> version        # non-zero exit = does not exist (hallucination)
    pip index versions <pkg>      # or: pip install <pkg>== to list
    go list -m <module>@latest
    cargo search <crate>
    ```
-   Non-existent, brand-new (days old), or near-zero-download → **stop**, treat as hallucination/slopsquat.
-2. **Typo-adjacency** — name within 1–2 chars of a far-more-popular package (`python-dateutil` vs `dateutil`, `lodahs` vs `lodash`)? Probably want the popular one — confirm before installing.
-3. **Version safety** — the model's pin may predate a CVE fix (training-cutoff reintroduction). Take the current patched release, then scan:
+   Non-existent, brand-new (published days ago), or near-zero-download → **stop**, treat as hallucination/slopsquat.
+2. **Typo-adjacency** — is the name within 1–2 chars of a far-more-popular package (`python-dateutil` vs `dateutil`, `lodahs` vs `lodash`)? If so, you probably want the popular one — confirm before installing.
+3. **Version safety** — the model's version pin may predate a CVE fix (training-cutoff reintroduction). Take the current patched release, then scan:
    ```bash
    npm audit           # block on high/critical
    pip-audit
@@ -51,7 +51,7 @@ PIN IT, LOCK IT, CVE-SCAN IT. NEVER PIPE A REMOTE SCRIPT STRAIGHT TO A SHELL.
    ```bash
    npm install --save-exact <pkg> && git add package-lock.json
    ```
-5. **License** — confirm compatible with the project's declared license before it lands.
+5. **License** — confirm the license is compatible with the project's declared license before it lands.
 6. **No pipe-to-shell** — never `curl … | bash` an install; download → inspect → execute over pinned HTTPS, or surface it to the user for confirmation.
 
 ## MCP-server intake — the dependency gate plus two extra checks
@@ -76,20 +76,20 @@ rg -n 'curl[^|]*\|\s*(bash|sh)|wget[^|]*\|\s*(bash|sh)' .
 
 ## Output format
 
-1. Per new dependency: name, resolved registry version, publish date / usage signal, and the existence-check command output (`npm view … → 4.17.21`) — proving it real.
+1. Per new dependency: name, resolved registry version, publish date / usage signal, and the existence-check command output (`npm view … → 4.17.21`) — proving it is real.
 2. The lockfile diff staged, and the `audit` / `osv-scanner` result (`0 high/critical`, or the finding + resolution).
-3. For any suggested install command, confirmation it isn't `curl|bash` and the source is pinned HTTPS.
+3. For any install command suggested, confirmation it is not `curl|bash` and the source is pinned HTTPS.
 
 ## Gotcha
 
-- Hallucinated names are *repeatable* — re-prompting the same model yields the same fake name, so "it looked confident / consistent" isn't evidence it exists. Only the registry is.
+- Hallucinated names are *repeatable* — re-prompting the same model yields the same fake name, so "it looked confident / consistent" is not evidence it exists. Only the registry is.
 - Short, "obvious" variants (`X-cli`, `X-client`, `X-sdk`) are the prime hallucination shape — verify these hardest.
 - A package that exists but was published this week with 12 downloads is a slopsquat candidate, not a safe dep — weigh age + usage, not just existence.
 - Lockfile integrity is part of the threat model: an unhashed or floating entry can pull a freshly-poisoned release even when a lockfile is "present".
 
 ## Do NOT
 
-- Do NOT run an install command for a package you haven't existence-checked this session.
+- Do NOT run an install command for a package you have not existence-checked this session.
 - Do NOT accept the model's version pin as authoritative — re-check against current CVEs.
 - Do NOT commit a manifest change without its lockfile.
 - Do NOT pipe a fetched script into an interpreter.

package/dist/agent-src/skills/systematic-debugging/SKILL.md

@@ -186,14 +186,14 @@ Pairs with [`context-hygiene § Read-Loop Detection`](../../rules/context-hygien
    the feedback loop.
 
 **Failure-signature triage — same taxonomy as [`context-hygiene § The 3-Failure Rule`](../../rules/context-hygiene.md#the-3-failure-rule).**
-The **failure signature** = **same target + same error class** (same failing test
-+ same assertion, same lint rule id, same build error). **Same failure signature
-twice → stop and pivot** — don't spend the next lap on a near-identical retry; a
-repeated identical signature means the hypothesis is wrong, not under-applied. A
-**new error signature each attempt = progress** and the counter continues. The
-**hard-blocker classes** (missing credentials, permission denied, spend/quota/rate
-limit, external-service `5xx`) skip retries entirely — surface on first
-occurrence; another lap cannot fix them.
+The **failure signature** is the **same target + same error class** (same failing
+test with the same assertion, same lint rule id, same build error). The **same
+failure signature twice → stop and pivot** — do not spend the next lap on a
+near-identical retry; a repeated identical signature means the hypothesis is
+wrong, not under-applied. A **new error signature each attempt = progress** and
+the counter continues. And the **hard-blocker classes** (missing credentials,
+permission denied, spend/quota/rate limit, external-service `5xx`) skip retries
+entirely — surface on first occurrence; another lap cannot fix them.
 
 **Anti-patterns this loop prevents:**
 
@@ -268,14 +268,14 @@ When reporting debug findings to the user:
 
 ## Knowledge capture (`mistake_made` event)
 
-Root cause traces to a `agents/knowledge/` page followed while
-implementing (documented convention wrong, API-shape page stale,
-procedure incomplete) → append a `mistake_made` event to the
-knowledge intake — never rewrite the page mid-task (see
-[`knowledge-pages`](../../templates/contexts/knowledge-pages.md)):
+If the root cause traces to a `agents/knowledge/` page that was
+followed while implementing (a documented convention was wrong, an
+API shape page was stale, a procedure was incomplete), append a
+`mistake_made` event to the knowledge intake — never rewrite the page
+mid-task (see [`knowledge-pages`](../../agent-src/templates/contexts/knowledge-pages.md)):
 
 ```bash
-./scripts-run src/scripts/emit_knowledge_event \
+npx tsx node_modules/@event4u/agent-config/src/scripts/emit_knowledge_event.ts \
     --type mistake_made \
     --error-category "<one or two words>" \
     --context-source "<agents/knowledge/... path, or 'null' if no page was followed>" \
@@ -283,17 +283,18 @@ knowledge intake — never rewrite the page mid-task (see
     --recurrence-key "<stable slug for this class of mistake>"
 ```
 
-Verify the append landed: check the command's exit code (0 =
-appended), then `grep <recurrenceKey> agents/knowledge/intake/events-*.jsonl`
+Verify the append landed: check the command's exit code (0 = appended),
+then `grep <recurrenceKey> agents/knowledge/intake/events-*.jsonl`
 finds the new line.
 
-**Live contradiction exception.** Followed page DEMONSTRABLY wrong
-right now (observed ≠ documented, not a one-off) → hybrid immediate-fix
-case instead — surface the correction, ask before continuing (see
-[`knowledge-pages`](../../templates/contexts/knowledge-pages.md) §
-Contested entries). Approved → isolated fix commit. Declined →
-`./scripts-run src/scripts/append_contested` on that page, then still
-emit the `context_stale` event above for the consolidation pass.
+**Live contradiction exception.** If the followed page is DEMONSTRABLY
+wrong right now (observed reality ≠ documented claim, not a one-off),
+this is the hybrid immediate-fix case instead — surface the proposed
+correction and ask before continuing (see
+[`knowledge-pages`](../../agent-src/templates/contexts/knowledge-pages.md)
+§ Contested entries). Approved → isolated fix commit. Declined →
+`npx tsx node_modules/@event4u/agent-config/src/scripts/append_contested.ts` on that page, then still
+emit the `context_stale` event above it for the consolidation pass.
 
 ## Gotchas
 

package/dist/agent-src/skills/tailwind-engineer/SKILL.md

@@ -134,9 +134,8 @@ Risks:          <arbitrary values, !important, dark-mode gaps>
   [`docs/guidelines/design-antipatterns.md`](../../../docs/guidelines/design-antipatterns.md)
   (C1 gradients, T7 fonts, L1/L2 layout, V1 side-stripe). Pull the catalog
   for the full list; the objective subset (contrast, font-size floor,
-  reduced-motion) is CI-enforced by
-  [`lint_design_quality`](../../../src/scripts/lint_design_quality.ts) for
-  consumer projects.
+  reduced-motion) is validated via `accessibility-auditor`'s checklist —
+  cite its verdict rather than eyeballing.
 - **Anti-AI-slop: gradients.** Unless audit-pinned or brief-explicit,
   avoid the default purple-to-blue / cyan-to-pink gradients on white —
   they read as auto-generated (catalog C1/C2). Reach for a single accent
@@ -154,7 +153,7 @@ Risks:          <arbitrary values, !important, dark-mode gaps>
 
 ## Taste Dials
 
-`DESIGN.md` `## Taste Dials` → honour: Variance → layout-family spread + asymmetry; Motion → animation budget + reduced-motion posture; Density → spacing scale + info-per-viewport. Absent → follow brief's inferred dials.
+When `DESIGN.md` declares `## Taste Dials`, honour them: Variance → layout-family spread + asymmetry tolerance; Motion → animation budget + reduced-motion posture; Density → spacing scale + information-per-viewport. Absent → follow the design brief's inferred dials.
 
 ## Do NOT
 

package/dist/agent-src/skills/technical-specification/SKILL.md

@@ -31,6 +31,11 @@ Do NOT use when:
 
 ## Procedure: Write a spec
 
+1. **Inspect existing specs and ADRs** — Read `agents/features/`, `agents/decisions/` (or `docs/adr/`) and any linked tickets to identify prior art, naming, and status conventions.
+2. **Pick the document shape** — Choose Technical Spec, PRD, RFC, or ADR based on audience (engineering vs. product) and decision irreversibility.
+3. **Draft the document** — Use the template below; fill Status, Summary, Problem, Goals, Non-Goals, Proposed Solution.
+4. **Verify** — Confirm goals are measurable, non-goals are explicit, and at least one reviewer is named before circulating.
+
 ### Technical Specification (full)
 
 For complex features or systems. Stored in `agents/features/` or module `agents/features/`.