@imolko/ultra-agent 0.1.0-beta

package/skills/wayfinder/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: wayfinder
+description: Plan a huge chunk of work — more than one agent session can hold — as a shared map of decision tickets, resolved one at a time until the way is clear.
+disable-model-invocation: true
+---
+
+# Wayfinder
+
+Plan a chunk of work too big for one agent session — a loose idea wrapped in fog, where the way from here to the **destination** isn't visible yet. Chart that way as a **shared map** on the issue tracker, then work its **decision tickets** — questions whose resolution is a decision, not a slice of build — one at a time until the route is clear.
+
+The destination varies per effort: a spec to hand off, a decision to lock before planning starts, a change made in place.
+
+Read `docs/agents/repo-config.md` for the repo pointers (`adr_dir`, `domain_dir`, `issue_language`, `tracker_cli`) — use them instead of hardcoded paths.
+
+Reference: A-036 (wayfinder labels + orthogonality), A-042 (map/ticket structure), A-037 (`exec::` dimension), A-034 (its place in the canonical set), A-038 (skills referenced by name), A-031/A-032 (domain vocabulary).
+
+## Plan, don't do
+
+Wayfinding is planning by default: each ticket resolves a decision, and the map is done when the way is clear — nothing left to decide before someone goes and does the thing. The pull to just do the work is usually the signal you've reached the edge of the map and it's time to hand off. An effort can override this in its Notas — carrying execution into the map — but absent that, produce decisions, not deliverables.
+
+## Refer by name
+
+Every map and ticket is an issue, so it has a name — its title. In everything the human reads, refer to it by that name, linked — the id and URL ride inside the link, never as a bare id.
+
+## The Map
+
+The map is a single issue labelled `wayfinder::map` — the canonical artifact. Its tickets are child issues of the map, linked at creation.
+
+The map is an **index**, not a store: a decision lives in exactly one place — its ticket — so the map only gists it and links, never restates it.
+
+### The map body
+
+The whole map at low resolution, loaded once per session. Open tickets are **not** listed — they are open child issues, found by query. The map's structure is owned by A-042 — this is its operational copy.
+
+```markdown
+# Destino
+
+<what reaching the end of this map looks like — one or two lines; every session orients to it before choosing a ticket>
+
+# Notas
+
+<domain and skills every session should consult; standing preferences for this effort>
+
+# Decisiones tomadas
+
+<!-- the index — one line per closed ticket: enough to judge relevance, then the link holds the detail -->
+
+- [<closed ticket title>](link) — <one-line gist of the answer>
+
+# Aún sin especificar
+
+<!-- in-scope fog you can't ticket yet; graduates as the frontier advances -->
+
+# Fuera de alcance
+
+<!-- work ruled beyond the destination; closed, never graduates -->
+```
+
+### Tickets
+
+Each ticket is a **child issue** of the map; its body is the question, sized to one agent session — the ticket structure is owned by A-042; this is its operational copy:
+
+```markdown
+# Pregunta
+
+<the decision or investigation this ticket resolves>
+
+# Bloqueado por
+
+<blocking tickets by title — or "Ninguno - puede iniciarse de inmediato">
+```
+
+Each ticket carries a `wayfinder::<type>` label — one of `research`, `spike`, `grilling`, `task` (see Ticket Types).
+
+A session **claims** a ticket by assigning it to the dev driving the map, first, before any work. That assignee is the claim: an open, unassigned ticket is unclaimed.
+
+Blocking is a **body convention** (`# Bloqueado por`), matching `/skill:to-tasks`: the tracker has native blocking (the `blocks` link type) but `tracker_cli` cannot wire links onto an existing issue, so the tracker can't render the frontier natively. A ticket is **unblocked** when every ticket named in `# Bloqueado por` is closed; the **frontier** is the open, unblocked, unclaimed children.
+
+The answer isn't part of the body — it's recorded on resolution. Assets created while resolving are linked from the issue, not pasted in.
+
+## Ticket Types
+
+Execution mode is the global `exec::` dimension (A-037): `AFK` resolves agent-alone, `HITL` resolves only through the live exchange — the human's side comes from the human, not the agent.
+
+- **research** (`exec::AFK`): surface a fact a decision waits on — docs, third-party APIs, local resources. Resolve with `/skill:research`.
+- **spike** (`exec::HITL`): raise the fidelity of the discussion with a cheap, rough, concrete artifact to react to. Resolve with `/skill:spike`.
+- **grilling** (`exec::HITL`): conversation; the default case. Always run `/skill:grill-me` and `/skill:domain-modeling`.
+- **task** (`exec::HITL` or `exec::AFK`): manual work that must happen before a *decision* can be made — nothing to decide, spike, or research, but the discussion is blocked until it's done. The one type that does rather than decides, and it earns its place by unblocking a decision.
+
+`wayfinder::<type>` answers only "what kind of decision" — never "who does it" (A-036).
+
+## Fog of war
+
+The map is deliberately incomplete: chart only what you can see. Beyond the live tickets lies the **fog of war** — decisions you can tell are coming but can't yet pin down, because they hang on questions still open. Resolving a ticket clears the fog ahead of it, graduating whatever's now specifiable into fresh tickets.
+
+**Fog or ticket?** The test is whether you can state the question precisely now — not whether you can answer it. Ticket when the question is already sharp (even if blocked); `# Aún sin especificar` when you can't yet phrase it that sharply.
+
+`# Aún sin especificar` excludes what's already decided (Decisiones tomadas), what's a live ticket, and what's out of scope.
+
+## Out of scope
+
+Fog only gathers toward the destination. Work beyond it is **out of scope** — not fog, and not in `# Aún sin especificar`. It gets its own `# Fuera de alcance` section.
+
+A ticket that turns out to sit past the destination gets **closed** and a one-line entry in `# Fuera de alcance` (gist plus why), linking the closed ticket. It stays out of Decisiones tomadas — a scope boundary isn't a step on the route.
+
+## Invocation
+
+Two modes. Either way, at most one ticket per session — research tickets excepted.
+
+### Chart the map
+
+User invokes with a loose idea.
+
+1. **Name the destination.** Run `/skill:grill-me` and `/skill:domain-modeling` to pin down what this map is finding its way to.
+2. **Map the frontier.** Grill breadth-first, surfacing the open decisions and the first steps takeable now. If this surfaces no fog — the way is already clear and the journey fits one session — you don't need a map; stop and ask the user how to proceed.
+3. **Create the map** (label `wayfinder::map`): Destino and Notas filled, Decisiones tomadas empty, the fog sketched into Aún sin especificar.
+4. **Create the tickets** you can specify now as children (`--linked-issues <map_iid>`), each with `# Bloqueado por` written in the body.
+5. **Resolve the research tickets** with `/skill:research` (AFK) — the one exception to one-ticket-per-session.
+6. Stop — charting is one session's work; it hand-resolves nothing else. Name the first frontier ticket and tell the user how to continue: `/handoff <first ticket>`, then re-open the map with `/skill:wayfinder` in the fresh session.
+
+### Work through the map
+
+User invokes with a map (URL or number); a ticket is optional.
+
+1. Load the **map** — the low-res view, not every ticket body.
+2. Choose the ticket: the one named by the user, else the first frontier ticket. **Claim it** by assigning it to yourself before any work.
+3. Resolve it — zoom into any related or closed ticket on demand; run the skills the Notas name. In doubt, run `/skill:grill-me` and `/skill:domain-modeling`.
+4. Record the resolution: post it as a comment, close the issue, and append a context pointer to Decisiones tomadas.
+5. Add newly-surfaced tickets; graduate any fog the answer made specifiable, clearing it from Aún sin especificar. If the answer reveals a ticket sits beyond the destination, rule it out of scope. If it invalidates other parts of the map, update or delete those tickets.
+6. **Hand off to the next session.** Name the next frontier ticket. If none remains, the way is clear — hand off (Plan, don't do). Otherwise tell the user how to continue: `/handoff <next ticket>`, then re-open the map with `/skill:wayfinder` in the fresh session.
+
+The user may run unblocked tickets in parallel — expect other sessions to edit the tracker concurrently.
+
+## Tracker mechanics
+
+Everything is `tracker_cli` (default `glab`). Map and ticket bodies follow the formatting rules owned by A-042.
+
+Create the map:
+
+```bash
+cat > /tmp/map-body.md << 'MAP_EOF'
+# Destino
+...
+# Notas
+...
+# Decisiones tomadas
+
+# Aún sin especificar
+...
+# Fuera de alcance
+
+MAP_EOF
+
+<tracker_cli> issue create --title "<map title>" --description "$(cat /tmp/map-body.md)" --label "wayfinder::map"
+```
+
+Create a ticket (child of the map):
+
+```bash
+cat > /tmp/ticket-body.md << 'TICKET_EOF'
+# Pregunta
+...
+# Bloqueado por
+...
+TICKET_EOF
+
+<tracker_cli> issue create --title "<ticket title>" --description "$(cat /tmp/ticket-body.md)" --label "wayfinder::<type>,exec::<MODE>" --linked-issues <MAP_IID>
+```
+
+`<MODE>` is the ticket's `exec::` value, from Ticket Types.
+
+Claim a ticket:
+
+```bash
+<tracker_cli> issue update <iid> --assignee @me
+```
+
+(If `@me` isn't accepted, use your literal tracker username.)
+
+Resolve a ticket:
+
+```bash
+<tracker_cli> issue note <iid> -m "<resolution>"
+<tracker_cli> issue close <iid>
+```
+
+Update the map's Decisiones tomadas (rewrite the whole body):
+
+```bash
+<tracker_cli> issue update <MAP_IID> --description "$(cat /tmp/map-body.md)"
+```
+
+Find open tickets by type:
+
+```bash
+<tracker_cli> issue list --label "wayfinder::<type>"
+```
+
+## Rules
+
+The map and ticket formatting rules are owned by A-042 — read and apply them from there, not restated here.

package/skills/workflow/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: workflow
+description: Map of the canonical skills and the order the development cycle flows. Use when unsure which skill to reach for, or to see the whole pipeline at once.
+disable-model-invocation: true
+---
+
+# Workflow
+
+The canonical skill set, in cycle order. Type a name to run it. The complete set lives in the package `@imolko/ultra-agent` — it is the canonical inventory (A-052); if a name here looks missing or stale, run `npx @imolko/ultra-agent update`.
+
+Read `docs/agents/repo-config.md` for the repo pointers (`adr_dir`, `domain_dir`, `issue_language`, `tracker_cli`) — use them instead of hardcoded paths.
+
+Reference: A-034 (the canonical set and the cycle model), A-038 (skills referenced by name), A-052 (repo pointers), A-035 (idea routing by candy), A-036 (wayfinder), A-039 (ship pipeline).
+
+## Entry points — you start these
+
+- `/skill:i-have-an-idea` — turn a raw idea into a grab-able worker-issue, routed by candy to the spec line or `/skill:wayfinder`.
+- `/skill:triage` — an incoming issue or merge request needs categorizing before any work.
+- `/skill:grill-me` → `/skill:to-specs` → `/skill:to-tasks` → `/skill:ship` — the spec line: stress-test the plan, synthesize the spec, slice it into tickets, fire the pipeline to an MR.
+- `/skill:wayfinder` — chart a big multi-session effort (8+ candies) or an unestimable `?` idea as a map of decision tickets.
+- `/skill:implement` — turn tickets into working code when a spec already exists.
+
+## Disciplines — the agent reaches these mid-work
+
+- `/skill:codebase-design` — vocabulary for where interfaces and seams live.
+- `/skill:domain-modeling` — change the domain model, or record a project-tier ADR.
+- `/skill:tdd` — the red-green loop.
+- `/skill:code-review` — Standards + Spec review of a diff.
+- `/skill:diagnose-bug` — a tight feedback loop for hard bugs.
+- `/skill:spike` — a throwaway UI, logic, or API spike.
+- `/skill:research` — investigate primary sources into cited notes.

package/skills/writing-for-agents/SKILL-MECHANICS.md

@@ -0,0 +1,32 @@
+# Skill mechanics
+
+The skill-specific branch of [`writing-for-agents`](SKILL.md): what changes when the document is a skill — frontmatter, the invocation choice, and router skills. Everything else about writing it is the universal reference in `SKILL.md`.
+
+## Frontmatter
+
+pi reads the Agent Skills fields below, with one pi quirk:
+
+- `name` — quirk: it need **not** match the directory name.
+- `description` — always in the system prompt. This is the skill's context-load cost — write it as the model-facing pointer (see `SKILL.md`).
+- `disable-model-invocation: true` — hides the skill from the system prompt; only the human can reach it (see [Invocation](#invocation)).
+- `argument-hint` — shown in the `/skill:name` autocomplete; `<angle brackets>` for required args, `[square brackets]` for optional.
+- Also accepted, rarely used here: `license`, `compatibility`, `metadata`, `allowed-tools`.
+
+## Invocation
+
+Two choices, trading the two loads:
+
+- A **model-invoked** skill keeps a `description`, so the agent can fire it autonomously — and other skills can reach it. You can still type its name: model-invocation always _includes_ user reach; a description only ever adds agent discovery, never removes the human's. The description is the skill's top-level context pointer, forced to stay loaded at all times — permanent context load in exchange for discoverability. Mechanics: omit `disable-model-invocation`, and write a model-facing description carrying the trigger branches (the pointer-writing rules in `SKILL.md` apply in full).
+- A **user-invoked** skill strips the description from the agent's reach: only the human typing its name can invoke it, and no other skill can. Zero context load, but it spends cognitive load — you are the index that must remember it exists. Mechanics: set `disable-model-invocation: true`; the `description` becomes human-facing — a one-line summary, trigger lists stripped.
+
+Pick model-invocation only when the agent must reach the skill on its own, or another skill must. If it only ever fires by hand, make it user-invoked and pay no context load.
+
+Shared reference that two user-invoked skills both need can live in neither — with no descriptions, neither can fire the other. Push it to a plain file outside the skill system: external reference any skill can point at.
+
+## Splitting by invocation
+
+The invocation cut of splitting (the sequence cut lives in `SKILL.md`): split off a model-invoked skill when a distinct leading word should trigger it on its own — a trigger word you actually use in your prompts. The always-loaded description must earn that independent reach.
+
+## Router skills
+
+When user-invoked skills multiply past what you can remember, that piled-up cognitive load is cured by a **router skill**: one user-invoked skill that names the others and when to reach for each, so the human has one skill to remember instead of many. It can only hint, never fire them: user-invoked skills have no description, so nothing but the human can reach them. In pi the human reaches them by typing `/skill:name`, so the router can name those literal commands — hinting, still not firing.

package/skills/writing-for-agents/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: writing-for-agents
+description: Writing documents for agents. Use when creating or editing a skill, authoring an ADR, or writing a standard the agent follows (a commit-message standard).
+---
+
+Reference for writing any document an agent consumes — a skill, an ADR, another standard the agent follows (a commit-message standard), a doc reached by a pointer. The packaging differs; the writing does not: the same levers make each one predictable — the agent taking the same _process_ every run, not producing the same output.
+
+When the document you're writing is a skill, read [`SKILL-MECHANICS.md`](SKILL-MECHANICS.md) for frontmatter, invocation choice, and router skills.
+
+When you're writing an ADR in this repo, read [`references/adrs.md`](references/adrs.md) for the worked example.
+
+Read `docs/agents/repo-config.md` for the repo pointers (`adr_dir`, `domain_dir`, `issue_language`, `tracker_cli`) — use them instead of hardcoded paths.
+
+## Context pointers
+
+A **context pointer** is a reference held in the agent's context that names some out-of-context material and encodes the condition for reaching it. A skill's description is one; a line in the ADR index (`<adr_dir>/index.md`) naming an ADR is the same object. The pointer's _wording_, not its target, decides when the agent reaches the material — and how reliably. A must-have target behind a weakly worded pointer is a variance bug: sharpen the wording first, and inline the material only if sharpening fails.
+
+A pointer does two jobs — state what the material is, and list the **branches** that should trigger reaching it (a branch is a distinct case the document handles, so different runs take different paths through it). Every word of an always-loaded pointer costs on every turn, so it earns even harder pruning than the body:
+
+- **Front-load the leading word** — the pointer is where it does its triggering work.
+- **One trigger per branch.** Synonyms that rename a single branch are one branch written twice; collapse them and keep only genuinely distinct branches.
+- **Cut identity the body already carries.**
+
+## The two loads
+
+Every document and pointer you add spends one of two budgets:
+
+- **Context load** — the cost of always-loaded material on the agent's window: a skill description, anything sitting in context every turn, spending tokens and attention whether or not it fires.
+- **Cognitive load** — the cost on the human: which documents exist and when to reach for each. The human is the index. Not a cost to minimise — it is the price of human agency; spend it where human judgement matters, remove it where it does not.
+
+Material reached only through a pointer escapes context load at the price of the pointer's own line; material with no pointer at all rides entirely on cognitive load.
+
+## Information hierarchy
+
+A document is built from two content types — **steps** (the ordered actions the agent performs) and **reference** (definitions, rules, facts consulted on demand) — that mix freely: all steps (a recipe), all reference (a review's rules, this skill), or both. The core decision is where each piece sits on the **information hierarchy**, a ladder ranked by how immediately the agent needs the material:
+
+1. **In-file step** — the primary tier: what the agent does, in order.
+2. **In-file reference** — consulted on demand. Often a legitimately flat peer-set (every rule of a review on one rung) — a fine arrangement, not a smell.
+3. **Disclosed reference** — pushed out into a separate file, reached by a context pointer, loaded only when the pointer fires. Spans a sibling file in the same folder through fully external reference that lives anywhere and any document can point at.
+
+Push too little down and the top bloats; push too much and you hide material the agent actually needs. That tension is the whole decision.
+
+**Progressive disclosure** is the move down the ladder — out of the main file and behind a pointer — so the top stays legible. Not primarily a token optimisation: it is how the hierarchy is protected. Branching is the cleanest disclosure test: inline what every branch needs, and push behind a pointer what only some branches reach. When a document has steps, in-file reference that should be disclosed buries them and turns attending to them into a coin-flip — a variance lever, not just a legibility one.
+
+**Co-location** is the within-file companion: where the ladder decides _how far down_ a piece sits, co-location decides _what sits beside it_ once there. Keep a concept's definition, rules, and caveats under one heading rather than scattered, so reading one part brings its neighbours with it. The test: the document should read like documentation written for the agent — grouped material reads that way; scattered material does not. (Distinct from duplication: that repeats one meaning in two places; scattering fragments one meaning across many.)
+
+**Sprawl** is the failure mode here: a document simply too long, even when every line is live and unique. Attention thins across the excess, and every extra line is one more to keep relevant. The cure is the ladder: disclose reference behind pointers, and split by branch or sequence so each path carries only what it needs.
+
+## Steps and completion criteria
+
+Every step ends on a **completion criterion** — the condition that tells the agent the work is done. Two properties make it a lever:
+
+- **Clarity** — can the agent tell done from not-done? A vague bound ("understanding reached") invites **premature completion**: ending the step before it is genuinely done, attention slipping to _being done_. The visible steps still ahead — the **post-completion steps** — supply the pull; the criterion's clarity is the resistance. Defend in order: **sharpen the bound first** (local and cheap); only if it is irreducibly fuzzy _and_ you observe the rush, hide the later steps by splitting the sequence — and hiding only works across a real context boundary (a hand-off or a subagent dispatch; an inline call leaves the later steps in context and clears nothing).
+- **Demand** — how much it requires. "Every modified model accounted for" forces thorough work where "produce a change list" does not. Demand drives **legwork** — the digging the agent does within the work, latent in the wording rather than written as its own step — and it is not step-bound: "every rule applied" binds a body of flat reference just as "every step done" binds a sequence, which is how an all-reference document still carries an exhaustiveness bar.
+
+The strongest criteria are both checkable and exhaustive.
+
+## When to split
+
+Splitting one document into two spends one of the two loads, so split only when the cut earns it:
+
+- **By sequence** — split a run of steps where the post-completion steps tempt the agent to rush the one in front of it. Keeping them out of view drives more legwork on the current task. Beware the reverse: merging sequences exposes each step's later steps to what follows, inviting premature completion.
+- **By invocation** — skill-specific: see [`SKILL-MECHANICS.md`](SKILL-MECHANICS.md).
+
+## Leading words
+
+A **leading word** is a compact concept already living in the model's pretraining that the agent thinks with while running the document (_lesson_, _fog of war_, _tracer bullets_). Repeated as a token, never as a sentence, it accumulates a distributed definition and anchors a whole region of behaviour in the fewest tokens, by recruiting priors the model already holds. Coining your own works if you define it clearly, but a made-up word recruits no priors — you pay in definition tokens what a pretrained word gives free; reach for an existing word first.
+
+It anchors twice. In the body, _execution_: the agent reaches for the same behaviour every time the word appears, and inside flat reference it focuses attention on a class of thing to look for. In a pointer, _invocation_: when the same word lives in your prompts, your docs, and your codebase, the agent links that shared language to the material and reaches it more reliably.
+
+Hunt for opportunities to refactor with leading words. A triad spelled out at three sites, a pointer spending a sentence to gesture at one idea — each is a passage begging to collapse into a single token:
+
+- "fast, deterministic, low-overhead" → _tight_ (a _tight_ loop).
+- "a loop you believe in" → _red_ — a fuzzy gate becomes a binary observable state (the loop goes _red_ on the bug, or it doesn't).
+
+You win twice: fewer tokens, and a sharper hook for the agent to hang its thinking on. Assume every document is carrying restatements that leading words retire — go find them.
+
+**Negation** is the failure mode beside this lever: steering by prohibition drags the forbidden behaviour into context and makes it _more_ available, not less. _Don't think of an elephant_, and the elephant is all there is; the negation is a weak modifier the strongly-activated concept overruns, so the ban half-reads as an instruction to do the thing. Prompt the **positive** — state the target behaviour ("write one-line comments") so the banned one is never spoken. A prohibition earns its place only as a hard guardrail you cannot phrase positively; even then, pair it with the positive target so attention lands on what to do.
+
+## Pruning
+
+- Keep each meaning in a **single source of truth**: one authoritative place, so changing the behaviour is a one-place edit. **Duplication** — the same meaning in more than one place — costs maintenance and tokens, and inflates a meaning's prominence on the ladder past its real rank. (The accidental inverse of a leading word, which repeats a token on purpose, never the meaning.)
+- The **ADR registry** is the source of truth for rules and mechanics — a document points at the owning ADR, never restates it.
+- The **environment** is a source of truth too — `package.json` scripts, config files, the directory layout, `--help` output — and a document that restates it is a **cache**: a copy of a lookup, earning its load only when the lookup is expensive. Cache what the agent cannot find by looking: the unwritten convention, the reason behind a choice, the gotcha no config confesses. Leave the one-file, one-command lookups to the environment, where they cannot go stale.
+- Check every line for **relevance**: does it still bear on what the document does? A line loses relevance by never bearing on the task (mere exposition, or a branch that should be disclosed) or by going stale as the behaviour or world it describes changes. Shorter documents are easier to keep relevant. Without a pruning discipline the default fate is **sediment**: stale layers that settle because adding feels safe and removing feels risky, until you must core down through them to find what is still live.
+- Hunt **no-ops** sentence by sentence: an instruction the model already obeys by default pays load to say nothing. The test — does it change behaviour versus the default? — is model-relative, not reader-relative: two people disagreeing about a no-op disagree about the default, and settle it by running the document, not by debate. When a sentence fails, delete the whole sentence rather than trim words from it. The test also grades leading words: a word too weak to beat the default (_be thorough_ when the agent is already thorough-ish) is a no-op, and the fix is a stronger word (_relentless_), not a different technique.

package/skills/writing-for-agents/references/adrs.md

@@ -0,0 +1,19 @@
+# Worked example: this repo's ADRs
+
+The ADRs in `<adr_dir>` are documents the coding agent reads and writes. They are also a live instance of the levers in `SKILL.md`. This file annotates the mapping; it points at the ADRs and never restates their content.
+
+The format, tier hierarchy, tag vocabulary, and lifecycle are owned by `<adr_dir>/ADR-0000-proceso-y-formato-de-adrs.md` (the meta-ADR). That file is the single source of truth — read it for the rules, and leave the rules there.
+
+## The levers, instantiated
+
+- **Checkable, exhaustive completion criterion.** The gate `scripts/verify-adr-consistency.py` must exit `0` with zero violations. "Done" is a binary, machine-checked state — not a vague "understanding reached". This is the completion-criterion lever from `SKILL.md`, applied to a whole document family.
+- **Environment as source of truth (the cache rule).** The gate's `hardcoded` rule *is* the cache principle, enforced by machine.
+- **Single source of truth.** `<adr_dir>/index.md` is the canonical index, enforced by the `indices` gate rule.
+- **Context pointers.** `<adr_dir>/index.md` names each ADR and its tier — a real pointer hub doing both jobs (states what the material is, encodes when to reach it). Each tier's `index.md` is the same object one level down.
+- **Co-location.** Each ADR keeps its format sections and frontmatter under one heading, so reading one part brings its neighbours with it.
+
+## When writing an ADR
+
+- Follow `ADR-0000` exactly: Nygard sections, the project frontmatter, the tier matching the decision's scope, the approved tag vocabulary, the numbering and lifecycle rules.
+- Run the gate before finishing: `python3 scripts/verify-adr-consistency.py`. Exit `0` is the completion criterion.
+- Link related ADRs by relative markdown path (the `jerarquia` and `enlaces` gate rules check this); point at them, don't restate them.