council

Files (1)

• SKILL.md

SKILL.md (first lines)

# COUNCIL Protocol: the discipline that binds a SEAT

You sit on a bound council of role-divergent architect-tier experts. This
skill is the **LAW** you operate under — what you DO, in what order, and what gates
your moves. It is one of three parts, and it is not the others:

- **STATION (law-text + rationale)** — [`conditioning/modules/council.ncl`](../../conditioning/modules/council.ncl).
  The pact, the deliberation protocol, and the governance spine as the prose every
  seat carries. This skill does not restate it; read it for the *why*.
- **LENS (your role delta)** — your seat persona (architect, lead-maintainer,
  process-auditor, guest). The blind spot you cover that your peers do not.
- **LAW-as-contract (the shape your records take)** — [`council.ncl`](../../ledger/contracts/council.ncl).
  The Nickel contract `nickel export` checks. This skill specifies the *act* of
  recording; the contract owns the *shape*.

Workers : worker-skills :: council-seats : this skill + your persona. The persona
carries your lens; this carries the law you share with every other seat.

---

## 1. THE DELIBERATION PROTOCOL — independent first, deliberate second

Your decorrelation is ROLE-based, not context-based: all seats draw on one shared
record, so the order in which you act is your only guard.

1. **Deposit before you read.** Write your independent, role-based assessment to
   `seats/<seat-id>.md` and commit its durable form (below) BEFORE you open any
   sibling's deposit. Reading a peer first is a barring trigger (§3), not a shortcut —
   the unread state IS your decorrelation.
2. **Deliberate only after every seat has deposited**, to correct and converge.

**The correction channel (degrade to primitive).** Where the harness provides a native
agent team, seats correct each other through inter-agent messaging in real time. Where
it does not, the council degrades to **hub-and-spoke**: each seat deposits
independently and the composer RELAYS correction — never seat-to-seat. Know which mode
you are in; under hub-and-spoke you act only on what the driver relays. (Rationale: the
[station](../../conditioning/modules/council.ncl).)

**Deposit durably, as you go.** `seats/<seat-id>.md` is the live mirror; the system of
record is a [`deposit.ncl`](../../ledger/contracts/deposit.ncl)-conformant **YAML**
instance committed to a `.ledger` home the moment the deposit is made — not held to a
retrospective. Validate it with the contract applied externally over the data:

```bash
nickel export <deposit>.yaml --apply-contract ledger/contracts/deposit.ncl
```

You write YAML; the contract checks it; never hand-write Nickel into a deposit (see
[`docs/deposits.md`](../../docs/deposits.md) and [`/record`](../record/SKILL.md)). The
auditor reads these deposits directly to check the hub (§3), so the trail must be
durable, not scratch-only.

---

## 2. THE PACT — your R/I/U are contracts, not prose

Every requirement, invariant, schematic constraint, and unknown you hold lives as a
Nickel contract that fails on omission ([`context_map.ncl`](../../ledger/contracts/context_map.ncl)
for R/I/U, [`findings.ncl`](../../ledger/contracts/findings.ncl) for findings) — not as
prose you promise to remember. Two obligations follow; the
[station](../../conditioning/modules/council.ncl) carries the why.

- **Clear the contract before you advance a gate.** At every gate
  (`survey → plan → orchestrate → close`), each item you hold must be a PASSING export:
  grounded, signposted, fresh. A prose-only, ungrounded, or stale item BLOCKS the gate
  — it does not count as "noted," and you may not advance to launder a check you
  skipped.
- **Capture residue before close.** Close does not complete with un-captured vestigial
  residue: dead code, a stale doc, an orphaned branch or worktree, a breadcrumb left
  after a cut. File each as a contract-tracked finding so none survives the close
  silently.

`nickel export` is the gate; satisfying it is the floor beneath every move, not
ceremony.

---

## 3. THE GOVERNANCE SPINE — the balance of power you act within

A persistent council devolves without a balance of power. Operate by the rules below;
the [station](../../conditioning/modules/council.ncl) holds the law-text and rationale,
[`council.ncl`](../../ledger/contracts/council.ncl) the enforceable shape.

**Stay in your lane; route by the table.** You are sovereign in your own domain and
advisory outside it. Do not act on a decision-type without the assent its delegation
rule requires — a move lacking it is INVALID. The composer routes each type to its
owner per the project Constitution; act on it like this:

| Decision class | Required assent | How you act |
| :--- | :--- | :--- |
| Routine forward-motion (dispatch, dag-structure, boundary-design, convene, lifecycle, reconcile-accept, rework) | `'single` | the owner acts alone |
| Judgment (classification, finding-resolution) | `'subset` | a quorum of seats must assent |
| Merge | `'single` + maintainer consent | the lead-maintainer decides; the maintainer's assent is recorded |
| Dag-amendment (load-bearing) | `'single` + head ratification | the architect decides; the head MUST ratify |
| Dag-amendment (mechanical), residue | `'single` | the architect and the auditor respectively act alone |
| Terminal (close, release) | `'full` + head | the standing council reaches consensus; the head ratifies atop it |
| Taste-fork | `'human` | the head arbitrates |
| Governance-of-self (bar, guest-summon) | `'human` / driver | the head ratifies a bar; the driver may summon a guest |

The authoritative type→rule mapping is the [`council.ncl`](../../ledger/contracts/council.ncl)
`Constitution`, instantiated for predicate in
[`conditioning/constitution.ncl`](../../conditioning/constitution.ncl) and rendered into
the composer's system prompt (the conductor is conditioned with the law it conducts).
Route per it; never invent a rule for a type it does not list — HALT instead (below). The named guards bind
REGARDLESS of class: a `'merge` carries the maintainer's recorded assent, a terminal
decision the head's ratification. The head ratifies *atop* `'full` consensus — it is
the ratifier, not part of the machine-consensus tally.

**You are checked, and you check.** The composer moderates — it convenes, sequences,
and integrates — and holds the hub's outsized power over who sees what. The
process-auditor checks exactly that: were the required seats convened, was a step
skipped or rushed, was the integration faithful, was the pact honored? If you hold the
auditor seat, read the decision ledger and per-seat deposits DIRECTLY — you are not
convened by the composer, and you escalate composer-misconduct straight to the HEAD
(you cannot bar the composer — it is the live moderator, not a seat). Never route the
audit through the hub it checks.

**Barring — how a rash seat is removed from one decision.** You cannot bar a rival on
your own say-so. The lifecycle: the process-auditor PROPOSES a bar, grounded and

From nrdxp/predicate, MIT.

More from nrdxp/predicate