@event4u/agent-config 14.6.0 → 14.8.0

package/dist/agent-src/skills/ai-council/references/output-and-synthesis.md

@@ -0,0 +1,125 @@
+# ai-council — output path and synthesis
+
+> Mode body of the [`ai-council`](../SKILL.md) skill (router-head retrofit,
+> 2026-08-20). Content moved VERBATIM from SKILL.md — load this file when the
+> mode table in SKILL.md routes here.
+
+## Output path convention
+
+Council artefacts (questions, responses, sessions) are **dev-time
+scratch** — gitignored in both the package repo and consumer repos
+and auto-pruned after `ai_council.session_retention_days` (default
+7). They inform a decision; they are not the durable contract. The
+durable contract lives in the roadmap / ADR / skill body that cites
+the council's convergence inline.
+
+**Linking to a specific council file is forbidden by
+[`no-roadmap-references`](../../../rules/no-roadmap-references.md)
+(council clause)** — gitignored, not in the cloned repo, gone after
+the retention window. Inline the convergence with date + members
+instead.
+
+Three directories, three modes:
+
+| Mode | Path | Format |
+|---|---|---|
+| **Topic-anchored question** (paired with a roadmap or ADR) | `agents/runtime/council/questions/<topic-slug>.md` | Markdown |
+| **Topic-anchored response** (paired with the question above) | `agents/runtime/council/responses/<topic-slug>.json` | JSON from `council:run --output` |
+| **Ad-hoc session** (no durable artefact yet) | `agents/runtime/council/sessions/<UTC-timestamp>.json` | JSON from `council:run --output` |
+
+`<topic-slug>` is kebab-case and **must match** the corresponding
+roadmap / ADR slug if one exists (e.g. `path-fixes` mirrors the
+matching `road-to-<topic-slug>` roadmap under `agents/roadmaps/`).
+
+### Forbidden
+
+- Files at `agents/` root (e.g. `agents/runtime/council/question-foo.md`).
+- Dot-prefix scratch (e.g. `agents/.council-question-foo.md`).
+- Any other directory below `agents/` (e.g. `agents/scratch/`,
+  `agents/evidence/notes/`). Operator scratch belongs under
+  `agents/runtime/tmp/` (gitignored).
+- Cross-references from any artefact to specific council files —
+  see [`no-roadmap-references`](../../../rules/no-roadmap-references.md)
+  (council clause). Inline the convergence summary instead, with
+  date and member list for traceability (`Council (claude-sonnet-4-5
+  + gpt-4o, YYYY-MM-DD) reviewed N candidate strategies; converged
+  on …`).
+
+### Exempt
+
+- `agents/evidence/audits/` — historical audit bundles. The canonical
+  council dirs are gitignored; audit bundles are tracked,
+  cohesive narratives that may include council artefacts as
+  part of their evidence trail (e.g. `audits/2026-05-14-north-star/`
+  bundling its triggering question, raw responses, and synthesis
+  alongside the audit's findings). The layout linter
+  (`scripts/check_council_layout.ts`) skips this directory.
+
+`scripts/check_council_layout.ts` is the mechanical check for the
+output path convention — wire it into the package's CI pipeline so
+violations break the build.
+
+## Synthesis templates (lens-aware)
+
+The **Convergence / Divergence** slot in `council:render` output is
+populated with a lens-specific synthesis prompt. The host agent reads
+this prompt and writes the summary in the shape it dictates. The five
+templates live in `scripts/ai_council/prompts.ts::_SYNTHESIS_TABLE`
+and are exposed via `synthesis_template(mode)`.
+
+**R4 Q4 split** — decision lenses get a structured Karpathy-style
+template; creative lenses keep an open-ended prose body. **Every lens
+now closes with two required verdict-discipline sections** — **Kill
+criteria** (observable falsifiers with a threshold or event, checkable
+without re-convening the council) and **Concrete next step** (exactly
+one artefact-producing action) — added so no synthesis ships an
+unfalsifiable verdict (road-to-opt-council-deliberation Phase 0):
+
+| Lens | Class | Synthesis sections |
+|---|---|---|
+| `default` | decision | Agreement · Clashes · Blind spots · Recommendation · **Kill criteria · Concrete next step** |
+| `pr` | decision | Consensus · Conflicts · Must-fix before merge · Recommendation · **Kill criteria · Concrete next step** |
+| `analysis` | decision | Top-10 by consensus · Supporting · Outliers · **Kill criteria · Concrete next step** |
+| `design` | creative | open prose body + **Kill criteria · Concrete next step** |
+| `optimize` | creative | open prose body + **Kill criteria · Concrete next step** |
+
+Input modes (`prompt` / `roadmap` / `diff` / `files`) inherit the
+`default` decision template — they are bundling shapes, not lenses.
+
+**Source citations:**
+* Template shape — Round 2 council verdict
+  (`agents/runtime/council/sessions/2026-05-14-ai-council-redesign/round-1.md`,
+  Opus's lens-adaptive synthesis proposal).
+* Decision/creative split — Round 4 Q4 verdict
+  (`agents/runtime/council/sessions/2026-05-14-ai-council-redesign/round-3-responses.json`).
+  R4 reframed `optimize` as creative because perf trade-offs resist
+  pre-templated shape — Performance-wins / Trade-offs /
+  Implementation-order is too rigid for the variety of optimize-lens
+  artefacts. R4 reframed `design` for the same reason — design
+  critiques are inherently narrative.
+
+### `--prose-synthesis` escape hatch (R4 Q4)
+
+Both `council:run` and `council:render` accept symmetric escape-hatch
+flags on top of the lens table:
+
+* `--prose-synthesis` — force creative-lens passthrough (bare slot)
+  regardless of lens. Use when the user on `default`/`pr`/`analysis`
+  prefers a narrative recommendation over the structured template.
+* `--no-prose-synthesis` — force the `default` structured template
+  even on a creative lens. Use when a `design` or `optimize` artefact
+  has a one-shot need for Karpathy-style structure.
+
+The flag is mutually exclusive — picking one disables the other on
+the same invocation. When `council:run` records either flag in the
+output JSON, `council:render` honours it unless the renderer is
+called with an explicit flag of its own.
+
+### Renderer lens resolution
+
+`council:render <responses.json>` resolves the active lens in this
+order: explicit `--prompt-mode` flag > `prompt_mode` field in the
+payload > `mode` field in the payload > `None` (default decision
+template). The `--prose-synthesis` / `--no-prose-synthesis` flag
+overrides the table regardless of how the lens resolved.
+

package/dist/agent-src/skills/ai-council/references/procedure.md

@@ -0,0 +1,143 @@
+# ai-council — procedure and critical evaluation
+
+> Mode body of the [`ai-council`](../SKILL.md) skill (router-head retrofit,
+> 2026-08-20). Content moved VERBATIM from SKILL.md — load this file when the
+> mode table in SKILL.md routes here.
+
+### Neutrality — context-handoff
+
+External reviewers do better critique when they know **what the
+project is**, not just what the artefact looks like. The council
+ships a neutral **handoff preamble** (modelled on `/agent-handoff`)
+in front of every member's system prompt, assembled by
+`prompts.handoff_preamble(project, original_ask)`:
+
+| Carried | Forbidden |
+|---|---|
+| Project name (from `composer.json` / `package.json` / repo dir) | Host-agent identity (Augment, Claude Code, Cursor, Cline, Windsurf, Copilot agent) — stripped line-by-line before send |
+| Stack one-liner inferred from manifest files | Host-agent reasoning, prior turns, internal analysis |
+| One paragraph of repo purpose from `README.md` (max 400 chars) | Host-agent framing language ("I think this looks weak", "the user probably wants…") |
+| The user's **original ask** verbatim (the free-form sentence that triggered `/council`) | Anything the host agent generated about the artefact |
+
+`detect_project_context()` in `scripts/ai_council/project_context.ts`
+reads only the manifest files + root README; missing fields collapse
+to `None` and the preamble silently omits the line. With both
+`project=None` and `original_ask=""`, the preamble degrades to the
+bare `NEUTRALITY_PREAMBLE` (v1 shape — back-compat for callers that
+have not migrated yet).
+
+## Procedure
+
+1. **Resolve target.** Identify the artefact mode (`prompt`, `roadmap`,
+   `diff`, `files`) and locate the source. Refuse to proceed if the
+   target is ambiguous.
+2. **Bundle + redact.** Call `scripts/ai_council/bundler.ts` to produce
+   a redacted artefact bundle. If `BundleTooLarge` fires, surface the
+   size and ask the user to narrow scope — do NOT truncate silently.
+3. **Clear the spend bound.** The council is standing-authorized — there is
+   no per-invocation approval. What still binds is a *bound*, resolved in
+   this order:
+   - **No billable member** (every member is `mode: cli` under
+     subscription auth — `billable=False`) → nothing is spent. Render the
+     estimate table as information and fan out. No gate.
+   - **Billable members with a configured ceiling** (`cost_budget.max_total_usd`
+     non-zero, or `daily_limit_usd` non-zero) → the ceiling **is** the
+     authorization the user already gave. Render the estimate and fan out.
+     `on_overrun` still fires per member on breach (below) — that is where
+     the user regains the decision.
+   - **Billable members with no ceiling at all** (`max_total_usd: 0` AND
+     `daily_limit_usd: 0`) → unbounded paid spend, so surface the estimate
+     and require an explicit `1`. Nothing bounds the call, so the user must.
+
+   Autonomy settings do not *create* a bound and do not lift the last case.
+   Consumers who want the old per-run gate back set a small
+   `cost_budget.max_total_usd`: every call then breaches and `on_overrun`
+   asks, per member.
+4. **Fan out.** Dispatch the bundle to each enabled council member via
+   `scripts/ai_council/orchestrator.ts`. Each member receives the
+   neutrality preamble from `prompts.ts` plus the artefact — nothing
+   from the host agent's prior reasoning.
+5. **Render results.** Stack each member's response under its own
+   provider-attributed heading. Never merge or paraphrase responses
+   into the host agent's voice.
+6. **Summarise.** Write a `Convergence / Divergence` block listing
+   agreements, disagreements, and unique insights — provider-attributed.
+7. **Critically evaluate** every finding before it leaves the host
+   (see *Critical evaluation* below). The host is the convener **and**
+   the skeptic — never a reviewer of the artefact itself, but always a
+   reviewer of the **council's output**.
+8. **Translate validated findings to options.** Convert each finding
+   the host accepts (or accepts with modification) into a concrete
+   numbered option for the user. Tag every option with the host's
+   verdict so the user sees the agent's reasoned position, not the
+   council's raw output. The user decides; the council advises; the
+   host filters.
+
+## Critical evaluation — convener-skeptic stance
+
+```
+COUNCIL CONVERGENCE IS NOT CORRECTNESS.
+DO NOT BLINDLY ACCEPT FINDINGS. DO NOT BLINDLY REJECT THEM.
+EVERY FINDING GETS A REASONED VERDICT BEFORE IT REACHES THE USER.
+```
+
+### Mechanism claims need a probe, not a second opinion
+
+```
+A MECHANISM CLAIM IN A COUNCIL ARTEFACT IS MARKED `unverified:` UNTIL A PROBE COVERS IT.
+A VERDICT RESTING ON AN UNVERIFIED MECHANISM CLAIM DOES NOT BIND.
+SEVERAL MODELS AGREEING MULTIPLIES PLAUSIBILITY. IT DOES NOT PRODUCE EVIDENCE.
+```
+
+A **mechanism claim** asserts how the machine behaves: "this toggle removes the
+cost", "that gate scans X", "the host reads the router". The council deliberates
+over **arguments**, never against the running system — it cannot execute a command,
+so it has no way to falsify one. Marking such a claim `unverified:` in the artefact
+keeps the reader from mistaking a well-argued mechanism for a measured one, and the
+non-binding clause means the fix for a wrong claim is a probe, not a re-vote.
+
+**Case zero (2026-07-29).** An accepted ADR claimed a compile-time toggle gave
+"zero-cost dormancy" because the rule was dropped from `dist/router.json`. Two
+council members praised the reasoning; neither could check it. A one-line `grep`
+later showed the toggle was read by the router compiler and by **nothing in the
+projector**, so the rule's body kept shipping as a file — and the host reads the
+file. The claim was half wrong, the verdict that rested on it was void, and what
+caught it was a probe, not a third opinion.
+
+The council is **uninformed about the codebase, ADRs, locked
+contracts, prior decisions, and project history** — it sees only the
+artefact + neutrality preamble. That is the source of its diversity
+**and** its blind spots. Convergence between members can mean shared
+generic best-practice priors, not project-specific correctness.
+
+The host applies a critical lens to **every finding** (convergence
+**and** divergence) before surfacing it as a numbered option:
+
+| Check | Question | Tool |
+|---|---|---|
+| **Codebase fit** | Does the finding match the actual code, files, signatures, conventions? | `view` / `codebase-retrieval` / `grep` |
+| **Locked-decision conflict** | Does it contradict an ADR, kernel rule, contract under `docs/contracts/`, or `docs/decisions/`? | `view` |
+| **Already addressed** | Is it a generic best-practice already covered by an existing rule, skill, or test? | `view` / `grep` |
+| **Cost / benefit** | Is the change worth the diff size, churn, and review cost vs. the marginal benefit? | reasoning |
+| **Hallucination** | Does the finding cite a file, function, or behavior that does not exist? | `view` |
+
+Each finding receives one of three verdicts:
+
+- **`accept`** — codebase fits, no locked-decision conflict, benefit clears cost. Surface as a normal numbered option.
+- **`accept-with-modification`** — core insight valid, but the proposed shape needs adjusting (wrong file, contradicts ADR detail, scope creep). Surface with the **modified** patch and a one-line note.
+- **`reject`** — finding is wrong (hallucinated reference, contradicts a locked decision, already addressed, generic noise). Surface as a **Rejected by host** entry with a one-line reason. Still visible — the user can override.
+
+The verdict is the host's **own** reasoning, not the council's.
+Pretending convergence equals correctness, or paraphrasing council
+output as host analysis, both breach the [`direct-answers`](../../../rules/direct-answers.md)
+no-invented-facts rule. When the host cannot reach a confident
+verdict on a finding (mixed evidence, ambiguous scope), it surfaces
+the finding as `needs-input` with the open question — the user
+decides, the host does not guess.
+
+### What this is NOT
+
+- **Not a re-review by the host.** The host did not write the artefact independently and cannot critique it independently — that boundary still holds.
+- **Not a vote against the council.** Rejecting a finding requires evidence (file, line, contract reference), not preference.
+- **Not silent filtering.** Every finding reaches the user with its verdict and reason. The user can pick a `reject` option and override the host.
+

package/dist/agent-src/skills/decision-record/SKILL.md

@@ -119,6 +119,21 @@ Write:
   law instead of a decision under current conditions; see
   [`decision-revisit-gate`](../../rules/decision-revisit-gate.md) for
   what happens when a later change is blocked by it without one.
+  It is an externally observable **condition**, never a cadence and never
+  permanence under a field name: `terminal`, `none`, "never" and "forever"
+  are invalid, and `unclassified` is legal only on an *existing* record
+  during the migration — never on the one you are locking now.
+- **Evidence + assumptions, split explicitly.** Every load-bearing factual
+  claim in the rationale either points at a basis ref — `file:line`, a URL, a
+  `docs/CLAIMS.md` claim id, a benchmark id — or is **labelled an
+  assumption**. There is no third state. Cite nothing and the record grades
+  `E0`, which is honest and publishable; a confident grade over no citations
+  is not. **Agreement is not evidence:** the council converging, or two
+  models liking the same option, is `provenance: agentic` with
+  `agentic_mode: council` — sources and measurements raise the grade,
+  consensus does not. A human product call records `E0` plus
+  `authority_basis: owner_intent` rather than a faked grade. Vocabulary:
+  [`adr-layout § Provenance and evidence`](../../../docs/contracts/adr-layout.md).
 
 ### 5. Wire the supersession chain (if any)
 
@@ -129,9 +144,34 @@ If this decision overrides a prior ADR:
   not "we now think differently".
 - Hand off the `supersedes:` linkage to `adr-create`.
 
-### 6. Hand off to file mechanics
+### 6. Admission gate — is this an ADR at all?
 
-Output the structured payload (below). The user — or
+Classify **before** handing off. A locked choice earns an ADR only when it is
+architecturally significant on at least one axis:
+
+- **Hard or costly to reverse** — a one-way door: public API shape, DB schema,
+  wire format, published identifier, migration.
+- **Broadly constraining** — it binds work outside the module that made it.
+- **Crosses a governed surface** — consumer contract, API, security or privacy
+  floor, package structure.
+
+None of the three → **no ADR**. The record still exists; it lands as a
+decision note in `agents/decisions/`, a config value, a measurement record in
+`docs/CLAIMS.md`, an experiment, or a roadmap item. Explicitly not ADRs: a
+temporary numeric threshold · a benchmark value · a model mapping · one-off
+release sequencing · a reversible local implementation detail.
+
+**The reference case is in this tree.** ADR-002 encodes `25 000 → 26 000` and
+a `4.0k` override ceiling as architecture law (`ADR-002:55`, `:62`), and
+ADR-114 then had to add another override while recording that 7 of 9 kernel
+rules already carry them (`ADR-114:74`). The *principle* — a kernel budget
+exists, is measured, and is capped — is the ADR. The numbers belong in a
+versioned budget contract with a regression gate, so a recalibration stops
+needing an architecture supersession.
+
+### 7. Hand off to file mechanics
+
+Gate passed → output the structured payload (below). The user — or
 `adr-create` — turns it into the file.
 
 ## Weighted-matrix mode (quantitative)
@@ -226,10 +266,22 @@ Consequences:
   - <becomes harder>
   ✗ <becomes impossible>
 
+Assumptions:
+  ~ <load-bearing claim with no basis ref>
+
+Evidence:
+  <basis ref>  — file:line | URL | CLAIMS id | benchmark id   (or: none — E0)
+
+Provenance: human | agentic | mixed | unknown   (agentic_mode: single | council | delegated)
+Grade:      E0 | E1 | E2 | E3 | E4             (authority_basis: evidence | owner_intent)
+
 Supersedes: <ADR-XYZ "title">  (if any)
 Trigger:    <what changed>     (if superseding)
+Revisit-if: <observable condition>
+
+Admission gate: ADR | decision note | config value | measurement | experiment | roadmap item
 
-Next: /adr-create  with the payload above
+Next: /adr-create  with the payload above   (only when the gate says ADR)
 ```
 
 ## Gotcha
@@ -240,6 +292,12 @@ Next: /adr-create  with the payload above
   cons for the chosen option, you have not understood it yet.
 - A supersession with no "what changed in the world" is a vibe
   pivot. Reject and ask.
+- An unlabelled guess is worse than a labelled one. A claim with no basis ref
+  and no assumption label reads as established fact to the next reader.
+- "The council agreed" is a provenance fact, not an evidence grade. If the
+  only support is agreement, the grade is `E0` — write it.
+- Writing an ADR for a threshold is how a recalibration becomes an
+  architecture supersession. Run the admission gate first.
 
 ## Do NOT
 

package/dist/agent-src/skills/decision-review/SKILL.md

@@ -93,6 +93,31 @@ available at the time it was made**, not against the outcome alone.
 A decision can be correct given the information then and still need
 revision now.
 
+**Read the record's axes in this order** — each step can end the review, so
+running them out of order pays for the expensive ones first:
+
+1. **Effective state** — status, `superseded_by`, amendments, whether the
+   `review_trigger` fired. `superseded`/`deprecated` is not a live lock at all.
+2. **`provenance`** (+ `agentic_mode`) — who decided; descriptive only.
+3. **`evidence.strength`** — E0–E4, claim-relative, not a count of sources.
+4. **`evidence.discovery`** — on E0, `incomplete` means *nobody looked*: a
+   discovery failure, not an evidence failure. Search before treating the
+   absence as established, or the grade measures the review, not the decision.
+5. **Current evidence** — what tree, measurements and sources say *today*.
+6. **Reversibility** — of the transition you propose, not of the original
+   decision. The routing unit is the transition, never the document.
+7. **Reserved dimensions** — `protected_dimensions`, `reopen_policy` (absent →
+   `unclassified`, which is not `owner`).
+
+Then price the reopen record from the grade × provenance burden table in
+[`adr-layout § The reopen record`](../../../docs/contracts/adr-layout.md) —
+cheap for an `E0`/`E1` agentic snapshot, *surfaced* rather than obeyed or
+overturned for `E0`/`E1` human, the standard five fields at `E2`, and those
+fields plus engaging the original evidence **in kind** at `E3`/`E4`. Read the
+table; do not reconstruct it from memory. The axes are defined by
+[`adr-layout § Provenance and evidence`](../../../docs/contracts/adr-layout.md),
+not here.
+
 ### 4. Verdict
 
 One of three:
@@ -298,6 +323,40 @@ in the rule; the lock catalog, fire steps, and failure modes live here.
    Identical ceremony for a typo-level amendment would cost more than asking
    the owner and the mechanism would die of its own weight.
 
+### The grade prices the record, never the authority
+
+```
+AN EVIDENCE GRADE IS A MEASUREMENT, NOT A PERMISSION.
+IT PRICES THE REOPEN RECORD AND THE REVIEW PRIORITY. IT CONFERS NO AUTHORITY.
+A LOW GRADE NEVER LETS AN AGENT SUPERSEDE A RECORD ON ITS OWN.
+```
+
+Nothing in the burden table changes **who** may act: venue comes from the
+discriminator, the trust boundaries the transition touches, and the
+owner-reserved rows — never from the grade.
+
+The coupling was proposed and refused: two council seats independently named it
+the design's central defect, because the party assigning the grade would also
+be the party gaining authority from it, and would additionally be
+self-classifying its own transition as `reversible-internal` — itself an
+authority-bearing classification. Calling the result "provisional" changes
+neither the trust boundary nor the blast radius. Whether an *independently
+validated* grade may ever reduce the authorization burden is owner-reserved and
+open: do not answer it here — it is the `authority-coupling-decision` blocker in
+`road-to-evidence-based-adr-governance`, and
+[`adr-layout § The reopen record`](../../../docs/contracts/adr-layout.md) closes
+on the same point.
+
+Two consequences that are easy to get backwards:
+
+- **An ADR's historical decision-maker does not determine its reopen venue.** A
+  record decided by a council does not need a council to reopen it; a record
+  decided by one agent is not thereby an agent's to overturn.
+- **A low-evidence record may state a decision; it does not establish that the
+  alternatives remain invalid.** *"We chose B because we had to choose"* is
+  legitimate and publishable — but never grounds for *"A is forbidden, the ADR
+  says B"*, which needs evidence the record never carried.
+
 ### When NOT to fire
 
 - The blocked change has no real benefit — the gate is not a lever to
@@ -324,6 +383,12 @@ in the rule; the lock catalog, fire steps, and failure modes live here.
   value-over-budget clause.
 - Silently dropping a good idea because "we already decided this" —
   the canonical failure the gate exists to stop.
+- Reading a low `evidence.strength` as permission to supersede — the grade
+  prices the record, it never moves the venue.
+- Treating `discovery: incomplete` as established absence: that grades the
+  review, not the decision.
+- Citing a low-evidence ADR as proof its rejected alternatives are still
+  invalid. It records a choice, not a refutation.
 
 ## See also
 

package/dist/agent-src/skills/merge-conflicts/SKILL.md

@@ -25,6 +25,32 @@ Use this skill when:
 
 ## Procedure: Resolve merge conflicts
 
+### 0. Classify before resolving — and never start in the GitHub web editor
+
+A `CONFLICTING` PR is not a signal to open the web editor. **The web editor
+cannot tell generated from authored**, so it presents a mechanical regeneration
+and a real human decision as the same three-way merge — which is how a generated
+file gets hand-merged into a state matching neither branch.
+
+So classify locally first, before resolving anything. Sort every conflicted path
+into three classes, because the correct resolution differs per class and only one
+of them is a judgement call:
+
+| Class | What it is | Resolution |
+|---|---|---|
+| **generated** | a build output, an index, a compiled manifest — anything a generator writes from a source in the tree | re-run the generator. **Never mix hunks**, and note that a *clean* auto-merge of a generated file is still wrong: it can produce a file matching neither branch |
+| **remeasured** | a baseline, budget, or ratchet number a CI gate compares against | re-run the measurement on the merged tree and record what it says. Two branches legitimately measured two different trees, so there is no side to take — and picking one is how a ratchet silently loosens |
+| **authored** | prose, source, config a human wrote | a human decision — read both sides. This is what the rest of this skill is about |
+
+Getting the class wrong is the expensive direction: hand-merging a generated
+file, or picking a side on a measured one, both produce a plausible-looking file
+that no branch ever had. If the project ships a tool that does this
+classification, run it before touching the conflict; where it does not, the
+three-way sort above is still the first step.
+
+This is a checklist item, not a gate — nothing enforces it
+(road-to-merge-hotspot-drawdown 4.3).
+
 ### 1. Understand the situation
 
 Before touching any conflict: