@event4u/agent-config 14.23.0 → 15.0.0

package/dist/agent-src/guidelines/agent-infra/size-and-scope.md

@@ -0,0 +1,229 @@
+# size-and-scope-guidelines
+
+## Purpose
+
+Ensure all system components stay:
+
+- readable
+- maintainable
+- executable
+- non-redundant
+
+Prevent:
+- oversized rules
+- bloated skills
+- command overreach
+- duplicated knowledge
+
+---
+
+# Core principle
+
+> Split by responsibility, NOT by length.
+
+Size is a signal — not the goal.
+
+---
+
+# Golden size rules
+
+## Rules & system instructions
+
+- Ideal: **< 60 lines**
+- Acceptable: **< 100–120 lines**
+- Hard limit: **< 200 lines**
+
+Linter (structural model, 2026-05-08 — see
+[`docs/contracts/linter-structural-model.md`](../../contracts/linter-structural-model.md)):
+the long-rule warning fires only when the rule is **> 60 non-empty
+lines AND density < 0.50 AND ships no Iron-Law block**. Rules whose
+body is a verbatim ALL-CAPS imperative (`commit-policy`,
+`ask-when-uncertain`, `direct-answers`) are auto-exempt — no
+frontmatter flag required. The 200-line hard error stays
+unconditional.
+
+Reason:
+- Loaded frequently
+- Must be reliably followed
+- Large files get partially ignored
+
+---
+
+## Skills
+
+- Target: **300–900 words**
+- Warning: **> 400 lines AND (density < 0.60 OR ≥ 2 `## Procedure`
+  blocks)** — structural model, 2026-05-08
+- Reference-rich skills with high density (`quality-tools` at 0.83,
+  catalogue-style skills) pass without splitting; the multi-procedure
+  trigger flags genuine cluster-split candidates regardless of size
+
+Focus:
+- scanability
+- one responsibility
+- executable workflow
+
+---
+
+## Commands
+
+- Target: **200–600 words**
+- Acceptable: **up to ~1000 words**
+- Warning: **> 1000 words AND no delegation signal AND density < 0.65**
+  — structural model, 2026-05-08. A delegation signal is either
+  frontmatter (`cluster:` / `routes_to:`) OR ≥ 3 markdown links to
+  other `.md` files. Well-factored orchestrators pass automatically;
+  inlined logic in a non-orchestrator command warns.
+
+Commands orchestrate — not implement.
+
+---
+
+## AGENTS.md
+
+- Enforced budget: **character caps** via `lint_agents_md.ts` — package
+  root fails at **3,000 chars** (warns 2,800); consumer template fails at
+  **2,500 chars** (warns 2,300).
+- Word guidance: aim for **≤ ~450 words** — that is roughly what fits
+  under the 3,000-char cap.
+
+High-level only.
+
+---
+
+## copilot-instructions.md
+
+- Ideal: **< 60 lines**
+- Acceptable: **< 100–150 lines**
+- Note: Copilot Code Review reads only the **first 4,000 characters**
+  (see `src/agent-src/templates/copilot-instructions.md`), so the
+  effective cap is character-based — highest-priority rules go up top.
+
+Must stay lightweight.
+
+---
+
+## Guidelines
+
+- Target: **400–1500 words**
+- Can exceed if needed
+
+Guidelines are reference — not execution.
+
+---
+
+## Knowledge cards
+
+Committed knowledge cards (`agents/knowledge/<source>.md`) are a size-bounded,
+evidence-disciplined context type:
+
+- Hard bound: **≤ 150 lines** — a card is a thin distillation, never a mirror.
+- **Mandatory** `links.authoritative` pointer (path or URL).
+- Enforced by `check_knowledge_cards.ts` (pointer-resolution CI + size +
+  trust-tag + multi-evidence git-ancestry consistency; `--strict` adds a
+  content-compare). Durable content = negative facts + pointers; positive
+  structure is a per-line, last-verified hypothesis.
+
+See [`source-discovery`](../../skills/source-discovery/SKILL.md) and the
+`evidence-discipline` context for the full model.
+
+---
+
+# Component responsibilities
+
+## Rules
+
+- constraints only
+- no workflows
+- no long explanations
+
+---
+
+## Skills
+
+Must contain:
+
+- When to use
+- Procedure
+- Validation
+- Output format
+- Gotchas
+- Do NOT
+
+---
+
+## Commands
+
+- orchestrate workflows
+- delegate to skills
+- do not contain deep logic
+
+---
+
+## Guidelines
+
+- define conventions
+- support skills
+- must NOT replace workflows
+
+---
+
+## AGENTS.md
+
+- entrypoint
+- system overview
+- interaction model
+
+---
+
+## copilot-instructions.md
+
+- behavioral hints
+- style guidance
+
+---
+
+# Anti-patterns
+
+## Too large
+
+- skill solves multiple problems
+- rule explains instead of constraining
+- command contains implementation
+- AGENTS.md becomes documentation dump
+
+---
+
+## Too small
+
+- skill has no real workflow
+- rule is just a suggestion
+- command adds no value
+
+---
+
+# Boundary rule (critical)
+
+> A skill must remain usable WITHOUT opening a guideline.
+
+If not → the skill is too weak.
+
+---
+
+# Decision checklist
+
+Before creating or modifying:
+
+1. Is this a constraint → Rule
+2. Is this a workflow → Skill
+3. Is this orchestration → Command
+4. Is this reference → Guideline
+5. Is this entrypoint → AGENTS.md
+6. Is this behavior hint → copilot-instructions.md
+
+---
+
+# Final principle
+
+> Small enough to understand quickly
+> Large enough to be useful

package/dist/agent-src/guidelines/agent-infra/skill-quality-checklist.md

@@ -0,0 +1,157 @@
+# Skill Quality
+
+> Creating, editing, or reviewing skills — minimum quality standard, every skill must be executable, validated, and self-contained
+
+_Origin: migrated from `.agent-src.uncondensed/rules/skill-quality.md` per P4.2 of `road-to-kernel-and-router.md`._
+
+# Skill Quality
+
+## Minimum Sharpness
+
+Every skill must answer four questions. If ANY answer is weak, the skill is not done.
+
+| # | Question | Section | Standard |
+|---|---|---|---|
+| 1 | When should I use this? | `When to use` | Concrete trigger, not generic |
+| 2 | What exactly do I do? | `Procedure` | Executable steps with decisions |
+| 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`.
+
+## Frontmatter Contract
+
+Every skill's YAML frontmatter MUST validate against `scripts/schemas/skill.schema.json`.
+Violations are reported by `scripts/skill_linter.ts` as `schema_<rule>` errors
+and fail `./scripts-run src/scripts/validate_frontmatter` and the full CI pipeline.
+
+### Omit fields equal to their schema default
+
+```
+NEVER write a frontmatter field whose value equals its schema `default`.
+OMIT IT — the loader injects the default at read time.
+```
+
+A field that carries the schema `default` (e.g. `trust.level: core`,
+`install.default: true`, `lifecycle: active`, `source: package`,
+`command.disable-model-invocation: true`) is redundant:
+`validate_frontmatter.apply_schema_defaults` injects it transparently for
+every consumer (validator, discovery manifest, drift checksum). Writing it
+anyway is boilerplate that `scripts/lint_frontmatter_boilerplate.ts` rejects
+(wired into this repository's `ci-fast` task). To strip it across the tree, run
+`./scripts-run src/scripts/migrate_frontmatter_defaults`. Background:
+`road-to-abstraction-reduction.md` +
+`agents/evidence/analysis/abstraction-reduction-preflight.md`.
+
+> **Changing a default is a breaking change.** The schema `default` is a
+> contract: artefacts that omit the field inherit whatever the default *is at
+> read time*. Flipping a default value (e.g. `lifecycle: active → deprecated`)
+> silently re-defaults every artefact that omits the field — so a default
+> change must pair with a re-run of `migrate_frontmatter_defaults.ts` and an
+> explicit review of the affected artefacts.
+
+## Description Triggering
+
+Claude routes skills by their frontmatter `description`. Pushy,
+trigger-rich descriptions are required — polite or hedged ones cause
+undertriggering. The full recipe (concrete verb phrase, ≥2 triggers,
+`even if they don't explicitly ask for …` tail, ≤200 chars,
+litmus test) lives in
+[`contexts/communication/rules-auto/skill-quality-mechanics.md`](../../contexts/communication/rules-auto/skill-quality-mechanics.md)
+§ Description Triggering.
+
+## Skill Independence
+
+```
+If a skill is not executable without opening a guideline, it is broken.
+```
+
+- Skills MAY reference guidelines for detailed conventions
+- Skills MUST NOT outsource their core workflow to guidelines
+- If removing guideline references makes the skill useless → the skill is too weak
+
+**Litmus test:** Cover all guideline references in the Procedure. Is it still executable?
+If not → the skill needs more own steps, decisions, and validation — not more guideline links.
+
+## Merge & Condensation Preservation
+
+When merging or condensing skills, the result MUST preserve the
+strongest validation, strongest examples, all anti-patterns, all
+decision criteria, and trigger quality. Full preservation invariants
+and "merge is invalid if …" / "condensation may remove …" lists in
+[`contexts/communication/rules-auto/skill-quality-mechanics.md`](../../contexts/communication/rules-auto/skill-quality-mechanics.md)
+§ Merge Preservation and § Condensation Preservation.
+
+## Refactor Safety
+
+When refactoring or optimizing skills:
+
+- NEVER weaken validation to pass linter
+- NEVER remove anti-patterns to reduce size
+- NEVER replace concrete checks with "verify it works"
+- NEVER merge skills if the result is broader than either source
+- ALWAYS run linter before and after — fail count must not increase
+
+## Senior-Tier Required Structure
+
+Skills with `tier: senior` in YAML frontmatter MUST carry four named
+blocks beyond the standard required sections:
+
+| # | Block | Heading / Location | Standard |
+|---|---|---|---|
+| 1 | Context-First lead | Frontmatter `description` | First sentence anchors the cognition cluster (domain + senior role); second sentence names the trigger. |
+| 2 | Related Skills | `## Related Skills` | Two-list pattern — `**WHEN to use this**` (situations this skill resolves) + `**WHEN NOT to use this**` (route-elsewhere peers, named). |
+| 3 | Proactive Triggers | `## When the agent should load this` | 3–5 concrete user-prompt patterns (paraphrases users actually type), not abstract categories. |
+| 4 | Output Artifacts | `## Output` | 1–4 named artifacts with shape (file path, table, markdown structure) — orchestrator-citable identifier each. |
+
+**Forward-only.** `scripts/skill_linter.ts` enforces these blocks for
+`tier: senior` skills only; mid-tier and untiered skills skip the
+check. No retrofit pass on existing Wing-1 skills.
+
+Subsection specs (≤ 6-line spec + 1 reference example each), good /
+bad pattern pairs, and the WHEN-NOT routing peer rules live in
+[`contexts/communication/rules-auto/skill-quality-mechanics.md`](../../contexts/communication/rules-auto/skill-quality-mechanics.md)
+§ Senior-tier patterns.
+
+## Structural Malice Floor
+
+`scripts/skill_linter.ts` runs five regex patterns against every
+skill / rule / command body — credential exfiltration, remote
+execution, force-push to a protected ref, world-readable secret
+files, and shell-injection in subprocess calls. A match emits
+``Issue("error", "malice:<pattern>", "<line>:<matched>")`` and the
+linter exits with code **3** (security-failure), distinct from
+exit 2 (build-failure) so CI surfaces can split the two.
+
+The check is **structural**, not semantic — it catches the shapes
+the [`tool-safety`](../../rules/tool-safety.md) rule denies in prose: hidden
+credentials, arbitrary execution, write-without-approval. Fixtures
+and the exit-code-3 contract live in
+[`tests/test_skill_linter_malice.py`](../../../tests/scripts/skill_linter.test.ts).
+
+## Confidence Tagging
+
+Senior-tier procedure steps MAY append `[CONFIDENCE: high|medium|low]`
+at the end of multi-step chains where the agent's evidence varies
+across steps. Optional but recommended when a step's output feeds a
+downstream decision.
+
+Text-tag form is deliberate. Emoji 🟢 / 🟡 / 🔴 is **not** allowed —
+collides with [`direct-answers`](../../rules/direct-answers.md) § Emoji scope
+(functional markers only). Linter does not enforce the tag itself;
+the rule documents the placement so authors converge on one form.

package/dist/agent-src/guidelines/agent-infra/source-confidentiality-mechanics.md

@@ -0,0 +1,109 @@
+# Source confidentiality — mechanics
+
+Migrated out of [`source-confidentiality`](../../rules/source-confidentiality.md)
+on 2026-08-29. The rule is delivered on **every subagent spawn**, so its body is
+paid per spawn; this material is reference read on demand. Nothing was dropped —
+the three sections below are the rule's own text, verbatim, and the rule keeps
+its Iron Laws and points here.
+
+### What "source-anonymous" claims, and what it explicitly does not
+
+```
+THE CLAIM IS ABOUT WHAT IS WRITTEN NEXT, NEVER ABOUT WHAT IS ALREADY RECORDED.
+NEVER DESCRIBE THIS AS ERADICATION, REMOVAL FROM HISTORY, OR A CLEAN REPOSITORY.
+COMMIT MESSAGES, MERGED PR BODIES AND OLD DIFFS REMAIN RECOVERABLE BY ANYONE
+WITH REPOSITORY ACCESS, AND NO PHASE OF THIS PROGRAMME CHANGES THAT.
+```
+
+The `whether-history-gets-rewritten` decision resolved **no rewrite** (AI
+council 2026-08-28, 2/2): the evidence estate rests on stable commit pins, and a
+`git filter-repo` would convert every past `reproduced at <sha>` into an
+unverifiable claim — a larger loss than the residual it removes, and one that
+would still not reach a pre-rewrite clone, a fork or a PR mirror. So the
+residual is **counted, not hidden**: the census artefact
+(`agents/evidence/reports/source-attribution-census.md`) carries a `residual:`
+field for the immutable surfaces, and "clean" always means "clean minus the
+recorded residual".
+
+### The two classes are opposites, and only one of them is a leak
+
+```
+HARVEST ATTRIBUTION IS PROHIBITED EVERYWHERE.
+LICENSE-REQUIRED ATTRIBUTION IS MANDATORY, AND LIVES ONLY IN THE LICENSE SURFACES.
+CONFLATING THEM IN EITHER DIRECTION IS A DEFECT: SCRUBBING A LICENSE NOTICE
+BREAKS A LEGAL OBLIGATION, AND HIDING A HARVEST BEHIND ONE IS THE LEAK.
+```
+
+The three license surfaces, by path — no others:
+
+- `CREDITS.md`
+- `docs/THIRD-PARTY-NOTICES.md`
+- `provenance/borrows.jsonl`
+
+An upstream name there is required by the license or by
+[`code-provenance`](code-provenance.md) and is never scrubbed. The same name in
+a roadmap, skill, rule, ADR or commit message is harvest attribution and is a
+defect. Every other `skip_paths` entry is a gate-own file or a vendored-cluster
+member carrying its own notice.
+
+## The gate also checks SHAPE, not only names
+
+A deny list can only catch a name somebody already wrote down; the next unknown
+source walks straight through it. `check_no_external_sources` therefore also
+flags attribution by **form** — a `> **Source:**` header whose value is neither
+an opaque round identifier nor an `ENC1:` token, a quoted
+`agents/tmp(.old)/<name>/` directory whose name is not opaque, and an
+un-allowlisted `github.com/<owner>/<repo>` URL — and it matches tracked **paths**
+against the deny set, not only file contents.
+
+Tiering, per the resolved `how-loud-the-slug-heuristic-is` decision (AI council
+2026-08-28, 2/2): **block inside `agents/**`, warn elsewhere** — slugs are
+ordinary content in integration code and docs, where blocking globally would
+drive the broad allowlisting that is worse than the gap it closes. The warn tier
+is written to a retained CI report (`--report <path>`), not merely printed, so
+it stays auditable. Pre-existing occurrences are a **shrink-only count** in
+`src/config/gate-violation-baselines.json`, never an allowlist: nothing is
+excused and a new occurrence fails immediately.
+
+## Why these four rules are unconditional
+
+Under ADR-236 (`docs/decisions/ADR-236-one-artefact-one-layer.md`) this rule is
+delivered by the PROJECT layer only — it exists to maintain this package, so the
+global layer no longer carries an unscoped twin of it. A `paths:`-scoped rule is
+**not re-injected after `/compact`** (ADR-227:79-80), so scoping it would mean the
+obligation silently disappears mid-session with nothing left to reload it.
+
+It is therefore delivered unconditionally, and the path triggers were removed
+rather than worked around. **This section is the shared record for all four such
+rules** — `no-roadmap-references`, `rule-type-governance` and `skill-quality` carry
+the same change and no note of their own. Two reasons: four copies of the rationale
+cost more standing context than the decision they explain, and the other three are
+migrated POINTER stubs held at their pointer's size by
+`check_rule_stub_ceiling` — prose added there is prose in the wrong place by that
+gate's own contract, which is what caught the first attempt to duplicate it.
+
+AI council 2026-08-20, 2/2 convergent on this option over three alternatives, with
+two independent decisive arguments. First: the obligation governs an **authoring
+decision**, which happens before any file exists for a path trigger to match — so
+path-scoping fails at greenfield creation whether or not a compaction ever occurs.
+Second: the measured cost is small against what the partition returns. Keeping an
+unscoped global copy was rejected because it re-creates the duplication the
+partition exists to remove; splitting the four by "has a CI gate" was rejected by
+both seats as the wrong axis — a validator observes an outcome, it does not hold an
+obligation during the session, and `rule-type-governance` has no gate at all.
+
+**Cost, measured and corrected.** An earlier revision of this note claimed 1,754
+tokens (1.8 % of the partition's 96,584-token saving). That figure was a
+`chars / 4` proxy over the projected files and **understated the real cost by about
+half**: `check_rule_activation_census`, which counts with the exact BPE tokenizer,
+measures the unconditional corpus growing **108,130 → 111,642, i.e. +3,512 tokens
+(3.6 %)** — and that number includes this rationale, which is why it lives in one
+place instead of four. The verdict does not depend on the figure: one seat argued
+the token axis was the wrong one entirely, the other that cost is a legitimate axis
+which simply loses this particular comparison. Both readings survive 3.6 %.
+
+## See also
+
+- [`source-confidentiality`](../../rules/source-confidentiality.md) — the rule these mechanics belong to.
+- [`code-provenance`](../../rules/code-provenance.md) — the license-required-attribution obligation the two-class split defers to.
+- `src/scripts/check_no_external_sources.ts` — the gate that implements the shape checks.

package/dist/agent-src/guidelines/agent-infra/symptom-driven-harvest-loop.md

@@ -0,0 +1,104 @@
+# Symptom-driven harvest loop
+
+> The procedure that turns an **operator's production symptom** into a roadmap
+> this repository can execute. It is the inverse of the source-driven harvest:
+> that one starts from external material pushed onto the repo and asks what is
+> worth adopting; this one starts from a failure someone hit in production and
+> pulls external material in **per confirmed defect**.
+>
+> Body of `road-to-symptom-driven-harvest-loop` Phase 2. It lives here rather
+> than inline in [`roadmap-writing`](../../skills/roadmap-writing/SKILL.md)
+> because that skill is already ~4.8k tokens — well past the 3,500-token band —
+> and a procedure needed a few times a quarter should not be paid for on every
+> roadmap-authoring turn. The skill carries the pointer.
+
+## When this applies
+
+An operator reports a failure in their own words — "runs never end", "the agent
+screenshots instead of reading the code" — rather than a defect with a file and
+a line. File it first under [`agents/tickets/symptoms/`](../../../agents/tickets/symptoms/README.md);
+that entry is what this loop resolves.
+
+Not this loop: a defect already traced to a file (that is a roadmap item), a
+feature request (roadmap or ticket), or external material arriving unprompted
+(the source-driven harvest family).
+
+## The four steps
+
+**1. Confirm against the live tree, at a pinned commit, before any external
+search.** One `file:line` per claim, and the pin recorded next to it. The
+ordering is the load-bearing part: searching externally first produces a plan
+about the ecosystem's problems rather than this tree's, and every subsequent
+round inherits that frame. A symptom that does not reproduce as a confirmed
+defect gets a `null:` block and stops here — that is a result.
+
+**2. Triangulate externally, per confirmed defect, never additively.** For each
+defect, and only for each defect: the host tool's own issue tracker, its official
+docs **fetched fresh**, and practitioner reports. Inverted form throughout — the
+defect is the anchor, the source is drawn in to explain or bound it. A source
+that matches no confirmed defect is not evidence for this roadmap; note it and
+drop it.
+
+**3. Iterate at least two further rounds, each stating its delta.** A round that
+changes nothing ends the loop early and says so. This is the step that is
+skipped under time pressure and the step that pays: on the first run of this
+loop, round 2 refuted a standing repo blocker from the official payload spec,
+imported a constraint that reshaped a whole phase from "block on invalid" to
+"command-hook, disk-fallback, block-once", and round 3 found a reopen-clause
+deadlock that was the *only* argument for reopening cancelled work at all. A
+one-pass version would have shipped a roadmap re-proposing cancelled items with
+no reopening argument and a mechanism the host would have broken.
+
+**4. Emit with a symptom→defect map and per-phase falsifiers.** The map is the
+artifact the operator can read: their words in one column, confirmed defects with
+anchors in the next, owning phase in the third. Every phase carries the
+measurement that would delete it.
+
+## Step 5, added by the first three runs: re-verify at adoption
+
+A roadmap drafted at a pin and adopted later is a **snapshot of an opinion about
+a tree that has since moved**. Before adopting, re-verify every repo claim at the
+current tip and record the deltas.
+
+This is not ceremony. Adopting the first three runs of this loop, 81 commits
+past their shared pin, re-verification found 32 of 36 claims still true — and:
+
+- one defect had **fixed itself** (a function measured as having zero production
+  callers had acquired one), which deleted a roadmap step before anyone built it;
+- one claim was **wrong at the pin too** (a count stated as six where the tree
+  binds seven), which no amount of re-reading the draft would have surfaced;
+- three anchors had **drifted** to new line numbers while their content held;
+- one cross-cutting conflict was invisible until two drafts were read together
+  (a proposed "adopt the artifact's code" duty against an existing
+  `NEVER ADOPT EXTERNAL CODE VERBATIM` Iron Law).
+
+The cheapest of those to find was the already-fixed one, and it was worth the
+most: an item prevented costs nothing to maintain.
+
+## Worked example — why round 2 is mandatory
+
+`hook_manifest.yaml` carried a comment stating that in-process subagents "inherit
+the host process env and cannot be marked per-spawn", and that comment had stood
+for months as a recorded blocker on a whole design axis. It was true about the
+mechanism it named — the env var — and false about the conclusion.
+
+Round 2 fetched the host's current payload specification, which states that tool
+events inside a subagent carry `agent_id` and `agent_type` precisely so
+subagent calls can be distinguished from main-thread ones. The env cannot mark a
+spawn; the payload already did. One fetch refuted a months-old blocker, and the
+axis it had closed reopened.
+
+The general shape: **a repo comment records what was tried, not what is
+possible.** Round 1 finds the comment and believes it, because it is this tree's
+own evidence. Only an external round can date it.
+
+## See also
+
+- [`roadmap-writing`](../../skills/roadmap-writing/SKILL.md) — the authoring
+  skill this procedure extends; it owns phases, falsifiers, and the output format.
+- [`agents/tickets/symptoms/README.md`](../../../agents/tickets/symptoms/README.md) —
+  the intake convention and the two resolution blocks.
+- [`source-discovery-gate`](../../rules/source-discovery-gate.md) — the
+  no-structural-claim-without-evidence rule step 1 is an application of.
+- [`external-reference-deep-dive`](../../rules/external-reference-deep-dive.md) —
+  how to read a named external source properly in step 2.