@naswerks/engineering-loop 0.5.1 → 0.6.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "naswerks",
       "description": "The engineering loop: docs-* knowledge loop, spec-* execution loop, and init for a fresh repository.",
-      "version": "0.5.1",
+      "version": "0.6.0",
       "source": "./"
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "naswerks",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "The engineering loop: a knowledge loop (docs-*) and an execution loop (spec-*) for repositories driven by hosted agent sessions, plus init to make a repository ready for both.",
   "author": { "name": "naswerks" },
   "license": "MIT",

package/CHANGELOG.md

@@ -5,6 +5,54 @@ version is the one in `package.json` and `.claude-plugin/plugin.json`, which mus
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-09-29
+
+### Changed
+
+- **Two skills are named for the seat kinds that run them.** `spec-parent` is now `spec-coordinator`, and
+  `spec-child` is now `spec-build`. A spec seat's skill is `spec-{kind}` for every kind; `fixit` rides
+  `spec-build`, and `docs-process` is its own skill. Invoke them as `/naswerks:spec-coordinator` and
+  `/naswerks:spec-build`. A control plane that seeds skills by name seeds the new names, with this version
+  as its pack floor.
+- **The coordinator's voice is spelled `COORDINATOR`.** The anchors are `## COORDINATOR RULING`,
+  `## COORDINATOR NOTE` and `## COORDINATOR ACCEPT` (beside `## OPERATOR RULING`), the ruling templates open
+  `COORDINATOR RESPONSE`, and a seat's own anchors are `## [seat·…] CLOSE-OUT RECEIPT` and
+  `## [seat·…] HOLDING`. A board written before this version spells them `## PARENT …` and `[child·…]`:
+  every grep the skills run reads both spellings, a parser that reads the anchors should too, and no seat
+  rewrites a heading already on its board.
+- The coordinator's close-out audit is filed as `sessions/coordinator-retrospective.md`; a reader takes
+  `sessions/parent-retrospective.md` in an effort begun before this version.
+- `spec-coordinator` no longer names a `parallel` spawn argument: a shared worktree holds one live seat at a
+  time, and parallel seats need separate worktrees, decided when the pipeline is created.
+- The retired-vocabulary census retires `parent` beside `chain` and `child`.
+- `docs-workflow.md` says the ignition brief is written whole at authoring and verified at ignition. The
+  sentence sits in § Templates, which a copy owns: see Upgrading, step 3.
+
+### Added
+
+- `pins/names.test.mjs`: every skill name the pack writes is a skill it carries, and every seat kind runs a
+  skill named for it. The kinds, their skills and the words shaped like a skill name that name none are one
+  list in `skills/init/scripts/owned.mjs`, which the doctor reads too.
+- `init doctor` degrades a brief whose `## The kick` names a skill this pack does not carry, and names the
+  coordinator's skill.
+
+### Upgrading from 0.5
+
+1. Take the release (`claude plugin marketplace update engineering-loop`, then
+   `claude plugin update naswerks@engineering-loop`) between efforts: a session that invokes `spec-parent`
+   or `spec-child` after the update finds no such skill.
+2. Re-copy the loop text of both references into `docs/_meta/`, keeping your repository-owned sections;
+   `init refresh` restamps and never touches loop text.
+3. Three places are yours, so neither `init refresh` nor a re-copy reaches them. Change each one that still
+   carries the old text:
+   - § The archive convention (repository-owned): `parent-retrospective.md` is `coordinator-retrospective.md`.
+   - § Templates (repository-owned): the ignition brief is "the coordinator seat's standing orders for the
+     run — written whole at authoring, verified at ignition" (it read "the parent seat's standing orders
+     for the run — two sections completed at ignition").
+   - `docs/_meta/doc-index.md`: the build-seat paragraph `init` wrote from its template names `spec-build`
+     (it read `spec-child`).
+4. Run `init doctor`. A brief whose kick still names a retired skill shows a DEGRADE row; change the kick.
+
 ## [0.5.1] - 2026-09-24
 
 ### Fixed

package/README.md

@@ -69,9 +69,9 @@ and never touches the rest of the text.
 | `docs-process` | docs | patch living docs from working docs, verified against code, then archive |
 | `docs-audit-feature` · `docs-audit-full` | docs | audit living docs against code |
 | `spec-pipeline` | spec | explode an approved plan into numbered specs |
-| `spec-parent` | spec | the coordinator seat |
+| `spec-coordinator` | spec | the coordinator seat |
 | `spec-seat` | spec | the contract every armed seat follows |
-| `spec-child` | spec | the build job for one spec |
+| `spec-build` | spec | the build job for one spec |
 | `spec-review` | spec | the outside look before the retrospective |
 | `spec-retro` | spec | the coordinator's close-out audit |
 | `spec-witness` | spec | a read-only verifier |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naswerks/engineering-loop",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "The engineering loop as a Claude Code plugin: a knowledge loop (docs-*), an execution loop (spec-*), and init for a fresh repository. The package root is the plugin root.",
   "license": "MIT",
   "type": "module",

package/references/docs-workflow.md

@@ -1,4 +1,4 @@
-<!-- naswerks-loop: version=0.5.1 -->
+<!-- naswerks-loop: version=0.6.0 -->
 # Docs Workflow
 
 > How knowledge flows through `docs/`: the loop, the folder rules, the templates, and the `docs-*` skills.
@@ -204,9 +204,9 @@ one** (via `spec-pipeline`). The trigger for the layout is simply *"does this ef
                                    (TWO files — questions ride the PLAN TLDR, and there are no
                                     status snapshots, because the tracker is committed live and
                                     its git history carries every revision)
-                                 code-review.md            the review seat's outside look, if
-                                                           the pipeline had a review row
-                                 parent-retrospective.md   the parent's inside look
+                                 code-review.md                the review seat's outside look, if
+                                                               the pipeline had a review row
+                                 coordinator-retrospective.md  the coordinator's inside look
                                These are TESTIMONY: an archive pass repairs links elsewhere and
                                leaves sessions/** byte-untouched. Older archived sessions may
                                still hold questions.md / status-after-*.md; that is historical
@@ -430,8 +430,8 @@ once the code is fixed. Keep entries one line, dated, and pointing at a `file:li
 ### Spec doc (a numbered pipeline — `spec-pipeline`)
 
 When a research idea graduates into a real plan, `spec-pipeline` explodes it into a numbered pipeline in
-`docs/research/{topic}/`: `00-ignition-brief.md` (the parent seat's standing orders for the run — two
-sections completed at ignition) · `01-{topic}.md` (the umbrella) · `02..NN-{slice}.md` (**one
+`docs/research/{topic}/`: `00-ignition-brief.md` (the coordinator seat's standing orders for the run —
+written whole at authoring, verified at ignition) · `01-{topic}.md` (the umbrella) · `02..NN-{slice}.md` (**one
 self-contained spec per planned session**) · `project-status.md` (the tracker, which carries its own
 section notes) · `live-checks.md` (the human's verification rows).
 Each per-session spec uses this template (carries `Builds on`/`Source:` so the chain stays navigable):
@@ -472,13 +472,13 @@ come from this copy, so a repository changes them once, here.
 |-------|------|-------------|
 | `docs-backlog` | Have an idea | Capture it as a research doc in `research/` |
 | `spec-pipeline` | A research idea is graduating into a real plan | Explode the plan into a numbered spec pipeline (umbrella + one self-contained spec per session + `project-status`) in `research/{topic}/`; the plan becomes ephemeral |
-| `spec-parent` | Right after `spec-pipeline` (same session, context-loaded) or to resume an effort fresh | Assume the coordinator seat: cut seat prompts (one per spec), review/verify TLDRs, give commit calls, own `project-status.md` — the same loop hand-cranked or hosted |
+| `spec-coordinator` | Right after `spec-pipeline` (same session, context-loaded) or to resume an effort fresh | Assume the coordinator seat: cut seat prompts (one per spec), review/verify TLDRs, give commit calls, own `project-status.md` — the same loop hand-cranked or hosted |
 | `spec-seat` | **Every** seat a coordinator arms — invoked FIRST, before the job skill | The CONTRACT, not a seat: the shared half of every seat's procedure — beliefs, plain-text PLAN TLDR, numbered questions w/ recommendations, six-section FINAL TLDR, commit only on the relayed call |
-| `spec-child` | Igniting a build or fixit seat — manually or platform-spawned, after `spec-seat` | The BUILD JOB only: one spec, the role's reading list, the pin taxonomy, the suite protocol; `fixit` variant for no-spec defect sessions. Its ceremony comes from `spec-seat` |
+| `spec-build` | Igniting a build or fixit seat — manually or platform-spawned, after `spec-seat` | The BUILD JOB only: one spec, the role's reading list, the pin taxonomy, the suite protocol; `fixit` variant for no-spec defect sessions. Its ceremony comes from `spec-seat` |
 | `spec-witness` | A pipeline looks wedged, actors' claims conflict, or you want a substrate-verified state report | The read-only fourth seat: the control plane's read lanes, transcripts, git; zero writes, zero rulings — the seats act, the human judges, the witness testifies |
-| `spec-ignite` | Right after `spec-pipeline` when the pipeline runs HOSTED (vs `spec-parent` for hand-cranked) | The ignition copilot: verify the committed brief, derive the stage card (the human clicks Create), "kick it", a hosted coordinator runs the pipeline; two verbal gates, everything announced, every UI gap a named finding |
+| `spec-ignite` | Right after `spec-pipeline` when the pipeline runs HOSTED (vs `spec-coordinator` for hand-cranked) | The ignition copilot: verify the committed brief, derive the stage card (the human clicks Create), "kick it", a hosted coordinator runs the pipeline; two verbal gates, everything announced, every UI gap a named finding |
 | `spec-review` | A pipeline's builds are done and it has a review row | The outside look, before the retro and before the PR: code + patterns + composition across session seams + the loop's own comms, in two independent passes. Files `sessions/code-review.md` and classifies which findings earn a fixit. **Its value is having none of the pipeline's context** |
-| `spec-retro` | The parent's LAST act, after any review and any fixit | The inside look: a substrate-verified grade, the ceremony audit (did the acts the seat believes it performed actually write rows?), the ledger reconciliation, the true economics, the blindnesses, and the ranked fixit backlog |
+| `spec-retro` | The coordinator's LAST act, after any review and any fixit | The inside look: a substrate-verified grade, the ceremony audit (did the acts the seat believes it performed actually write rows?), the ledger reconciliation, the true economics, the blindnesses, and the ranked fixit backlog |
 | `docs-status` | Session start | Report what's recently archived, what's in `working/`, what's in `research/`; sweep the meta-comments for the condensed status table |
 | `docs-write` | End of a session | Finalize the working doc; it stays in `working/` (records its `## Archive` target) |
 | `docs-process` | Start of a session, `working/` has docs | Patch living docs from the working doc's checklist (verified vs code), then file the doc into `archive/` |

package/references/engineering-loop.md

@@ -1,11 +1,11 @@
-<!-- naswerks-loop: version=0.5.1 -->
+<!-- naswerks-loop: version=0.6.0 -->
 # The Engineering Loop — flow, seats, skills, and the ceremony
 
 > The quick intro to how work gets built with this loop: the two loops (`docs-*` knowledge, `spec-*`
 > execution), the seats (Human / Coordinator / Seat, plus the read-only Witness), the ceremony per
 > session, and a bare-bones exchange showing the back-and-forth. Point newcomers at this plus
 > [doc-index](doc-index.md) + [docs-workflow](docs-workflow.md). Operational templates live in the
-> `spec-parent` skill; the seat contract in `spec-seat`.
+> `spec-coordinator` skill; the seat contract in `spec-seat`.
 <!-- meta: type=guide; status=current; verified={date}; lineage=1 -->
 
 ---
@@ -38,7 +38,7 @@ Plan graduates          -> spec-pipeline         -> docs/research/{topic}/: umbr
                                                     per session + project-status.md (the plan is
                                                     now throwaway — the specs carry every crumb)
 Same session — CHOOSE THE SEAT:
-  hand-cranked          -> spec-parent           -> this session becomes the COORDINATOR and cuts
+  hand-cranked          -> spec-coordinator      -> this session becomes the COORDINATOR and cuts
                                                     Prompt #1 (you relay every message)
   hosted                -> spec-ignite           -> this session becomes the IGNITION COPILOT:
                                                     verify the brief, derive the stage card, YOU
@@ -108,13 +108,13 @@ What a commit and a PR pass here, beyond the loop. These add to the Hard rules b
   just *plan, build, `docs-write`, `docs-process`* — no pipeline, no coordinator, a flat working
   doc. This is the default and it never requires a control plane.
 - **`spec-*` is the execution loop** for work that is more than one session: `spec-pipeline`
-  graduates the plan, `spec-parent` takes the seat, build seats build one spec each. **Each spec is sized
+  graduates the plan, `spec-coordinator` takes the seat, build seats build one spec each. **Each spec is sized
   for ONE session** — recon, plan, build, suite and FINAL TLDR before the session's context compacts —
   and the spec count falls out of that: a pipeline of two specs is a pipeline, and so is one of ten. It
   hands off to the knowledge loop at both ends (research docs in, working docs out).
 - **Either loop runs by hand or hosted.** The manual version is this document's ceremony with the human
   relaying; the hosted version is the control plane running the same ceremony, machine-relayed. When they
-  drift, this doc + the `spec-parent` skill are the requirements; the control plane follows.
+  drift, this doc + the `spec-coordinator` skill are the requirements; the control plane follows.
 
 ## The seats
 
@@ -126,7 +126,7 @@ What a commit and a PR pass here, beyond the loop. These add to the Hard rules b
 | **Witness** *(optional, `spec-witness`)* | a read-only session with substrate access | testifies from rows/transcripts/git when claims conflict or a pipeline looks wedged; answers "whose turn is it" | writes anything; injects anything; rules on anything |
 
 The seat, not the chat, is the product: `project-status.md` must stay current enough that a
-fresh session can resume as coordinator losslessly (`spec-parent {topic}`).
+fresh session can resume as coordinator losslessly (`spec-coordinator {topic}`).
 
 ## The skills
 
@@ -138,10 +138,10 @@ fresh session can resume as coordinator losslessly (`spec-parent {topic}`).
 | `docs-process` | docs | effort done, fresh session | patch living docs (verified vs code), archive |
 | `docs-audit-feature` / `docs-audit-full` | docs | doc suspected stale / monthly | deep-audit docs against code |
 | `spec-pipeline` | spec | a plan came through and you're committing to it | explode the plan into a numbered spec pipeline — *spare no crumb* |
-| `spec-parent` | spec | right after `spec-pipeline` (same session) or fresh with the topic | assume the coordinator seat |
-| `spec-seat` | spec | **every** seat the coordinator arms, invoked FIRST | **the CONTRACT, not a seat** — the shared half of every seat's procedure. `spec-parent` does NOT compose it: the coordinator writes rulings rather than receiving them |
-| `spec-child` | spec | igniting a build or fixit seat — manual (`spec-child {role} {spec}`) or hosted | **the BUILD JOB only** — one spec, the role's adds, the pin taxonomy, the suite protocol, the fixit variant. Its ceremony comes from `spec-seat` |
-| `spec-ignite` | spec | when an authored pipeline runs HOSTED (the `spec-parent` alternative) | the ignition copilot, and it can run COLD: gates, re-verify the brief's baselines + platform state against live HEAD, derive the stage card (human clicks Create), "kick it" with the brief's own kick text as the task; every UI gap a named finding |
+| `spec-coordinator` | spec | right after `spec-pipeline` (same session) or fresh with the topic | assume the coordinator seat |
+| `spec-seat` | spec | **every** seat the coordinator arms, invoked FIRST | **the CONTRACT, not a seat** — the shared half of every seat's procedure. `spec-coordinator` does NOT compose it: the coordinator writes rulings rather than receiving them |
+| `spec-build` | spec | igniting a build or fixit seat — manual (`spec-build {role} {spec}`) or hosted | **the BUILD JOB only** — one spec, the role's adds, the pin taxonomy, the suite protocol, the fixit variant. Its ceremony comes from `spec-seat` |
+| `spec-ignite` | spec | when an authored pipeline runs HOSTED (the `spec-coordinator` alternative) | the ignition copilot, and it can run COLD: gates, re-verify the brief's baselines + platform state against live HEAD, derive the stage card (human clicks Create), "kick it" with the brief's own kick text as the task; every UI gap a named finding |
 | `spec-review` | spec | a pipeline's builds are done, if it has a review row | the OUTSIDE look, before the retro and before the PR: correctness/security/**composition across session seams** · the patterns, with every departure identified · the loop's own comms. Two independent passes, consolidated. Classifies which findings earn a fixit; **its value is having none of the pipeline's context** |
 | `spec-retro` | spec | the coordinator's LAST act, after any review and any fixit | the INSIDE look: a substrate-verified grade, the ceremony audit (did the acts write rows?), the ledger reconciliation, the true economics, the blindnesses, the ranked fixit backlog — *a retrospective that cannot indict its own author is marketing* |
 | `spec-witness` | spec | a pipeline looks wedged, or actors' claims conflict | the read-only fourth seat: substrate access, zero writes, zero rulings |
@@ -155,7 +155,7 @@ The thing that keeps prompts and skills from drifting apart:
 |---|---|---|
 | **POLICY** | the policy document § This repository's rails names — and, hosted, the un-skippable system-prompt suffix the control plane supplies at open | cannot be skipped, present on every turn |
 | **PROCEDURE — shared** | `spec-seat` | the contract for ANY seat the coordinator arms: blackboard, question lane, parked-call discriminator, verdicts, BELIEFS sha, git shapes, six-section FINAL TLDR, close-out order |
-| **PROCEDURE — per job** | `spec-child` · `spec-review` · `docs-process` | what THIS seat does. The job skill **refines** the seat contract and never contradicts it; a genuine conflict is a finding, not a fork |
+| **PROCEDURE — per job** | `spec-build` · `spec-review` · `docs-process` | what THIS seat does. The job skill **refines** the seat contract and never contradicts it; a genuine conflict is a finding, not a fork |
 | **TASK** | the seed prompt + the pipeline's `00-ignition-brief.md` | per-run; dies with the run |
 
 A seed's first act is therefore to **invoke its skills** — `spec-seat`, then the job — not to restate them.
@@ -174,7 +174,7 @@ diff.
 ## The ceremony (one build session)
 
 1. **Coordinator cuts the seat prompt** from the PREVIOUS session's actual shipped shapes — never
-   from the spec's guesses alone. (Template: `spec-parent` skill.)
+   from the spec's guesses alone. (Template: `spec-coordinator` skill.)
 2. **Seat recons, states its beliefs** (HEAD sha, dirty files, versions, baselines), then a
    **PLAN TLDR as plain text** — before any plan-approval presentation — with **questions as
    numbered options + an embedded recommendation, then STOP**. Never an interactive question tool.
@@ -208,7 +208,7 @@ COORDINATOR -> Prompt #N: docs preamble, ##PROMPT##, ONE spec + context docs + p
                + CEREMONY block
 SEAT        -> PLAN TLDR (BELIEFS: head/dirty/versions/baselines · the plan, 5-10 lines ·
                QUESTIONS 1..n, options + recommendation), STOP
-COORDINATOR -> PARENT RESPONSE — PLAN {ACCEPTED / ACCEPTED-WITH-RIDERS / …} · rulings 1..n
+COORDINATOR -> COORDINATOR RESPONSE — PLAN {ACCEPTED / ACCEPTED-WITH-RIDERS / …} · rulings 1..n
                (DECISION — why) · riders · "Go build."
 SEAT        -> (builds free; mid-run question: numbered text, STOP; COORDINATOR ruling; resume)
 SEAT        -> FINAL TLDR — (a) SHIPPED+VERIFICATION (b) VERBATIM RUNNER SUMMARIES (c) HONEST GAPS
@@ -225,7 +225,7 @@ The exchange above is not just chat — it is a pair of FILES per build session:
 
 - **`tldr.md` — the chat.** Append-only, two voices: the seat's PLAN TLDR + numbered
   questions, the coordinator's ruling appended beneath them, optional mid-build updates +
-  `## PARENT NOTE`s, then the FINAL TLDR. Read top-to-bottom it IS the session's whole
+  `## COORDINATOR NOTE`s, then the FINAL TLDR. Read top-to-bottom it IS the session's whole
   conversation, greppable by anchor.
 - **`plan.md` — the document.** The full plan, posted once, corrected on pushback. PULL-only:
   the coordinator reads it on a `read-full-plan` verdict; it is never force-fed into a wake or chat.
@@ -237,11 +237,11 @@ with the effort:
 
 ```
 docs/research/{topic}/sessions/         <- per-session work in {spec-slug}/, effort-wide at the root
-  {spec-slug}/plan.md        each seat   the full plan, posted once, corrected on pushback (PULL-only)
-  {spec-slug}/tldr.md        each seat   the two-voice chat — seat turns AND coordinator rulings interleaved
-  code-review.md             the review  the outside look, if the pipeline had a review row
-  parent-retrospective.md    the coord.  the close-out audit (the inside look)
-  witness-ledger-*.md        a human     the witness is zero-writes, so its ledger arrives by hand
+  {spec-slug}/plan.md           each seat   the full plan, posted once, corrected on pushback (PULL-only)
+  {spec-slug}/tldr.md           each seat   the two-voice chat — seat turns AND coordinator rulings interleaved
+  code-review.md                the review  the outside look, if the pipeline had a review row
+  coordinator-retrospective.md  the coord.  the close-out audit (the inside look)
+  witness-ledger-*.md           a human     the witness is zero-writes, so its ledger arrives by hand
 ```
 
 Two files per build session; questions ride the TLDR, and there are no status snapshots because the
@@ -264,39 +264,40 @@ though it can be fed.**
 **The coordinator's voice is NOT in the seat's file on the hosted plane.** A coordinator answers with
 `callout` (its sixth drive verb, machine-written, the only downward path), which persists on its own
 artifact lane and closes the question in the **acts ledger**. So **the file says whether a question was
-ASKED; the ledger says whether it was ANSWERED**, and a seat typing a parent-voice heading into its own
-TLDR closes nothing. `callout` **refuses when the charge has no live session** — a coordinator must
+ASKED; the ledger says whether it was ANSWERED**, and a seat typing a coordinator-voice heading into its
+own TLDR closes nothing. `callout` **refuses when the charge has no live session** — a coordinator must
 `seat_spawn` before it can rule — and reports **"RULING RECORDED, NOT DELIVERED"** in those words if the
 transport drops it.
 
-The parent-voice block (machinery-written hosted; the hand-cranked coordinator writes it — hand-cranked
-there is no rev counter, so the heading is `## PARENT RULING (plan — {verdict})`; the stable grep prefix
-`## PARENT RULING` is the contract in both modes):
+The coordinator-voice block (machinery-written hosted; the hand-cranked coordinator writes it —
+hand-cranked there is no rev counter, so the heading is `## COORDINATOR RULING (plan — {verdict})`; the
+stable grep prefix `## COORDINATOR RULING` is the contract in both modes, and an older board's
+`## PARENT RULING` is read as the same heading):
 
 ```
-## PARENT RULING (plan rev N — {accept | accept-with-riders | blocking-precondition})
+## COORDINATOR RULING (plan rev N — {accept | accept-with-riders | blocking-precondition})
 
-PARENT RESPONSE — PLAN TLDR {VERDICT}. {one sentence naming the best thing in the plan}
+COORDINATOR RESPONSE — PLAN TLDR {VERDICT}. {one sentence naming the best thing in the plan}
 Answers:
 1. {RULING IN CAPS} — {decision first, then the why}.
 ...
 Go build. Fold the riders in — no re-approval round-trip.
 ```
 
-Callouts and nudges append as `## PARENT NOTE` (actor-suffixed when known, e.g. `(operator)`).
+Callouts and nudges append as `## COORDINATOR NOTE` (actor-suffixed when known, e.g. `(operator)`).
 
 **The seat's own two anchors:**
 
 ```
-## [child·{slug} · run {id}] CLOSE-OUT RECEIPT     <- after the push
-## [child·{slug} · run {id}] HOLDING              <- "I have pushed and I am waiting"
+## [seat·{slug} · run {id}] CLOSE-OUT RECEIPT     <- after the push
+## [seat·{slug} · run {id}] HOLDING              <- "I have pushed and I am waiting"
 ```
 
 **A question heading, a HOLDING and a close-out receipt are ALL non-staling** — the gates bind an
 acceptance to the accepted CONTENT, not to the revision number, so appending your own *state* leaves it
 intact. Only **new content** stales. A seat that has pushed and is waiting is otherwise indistinguishable
 from a seat that has done nothing, and a coordinator reading a wake led by its own acceptance concludes
-there is nothing to rule — the HOLDING anchor is what prevents that. The token is the literal `child·`
+there is nothing to rule — the HOLDING anchor is what prevents that. The token is the literal `seat·`
 whatever seat you are — it is a protocol anchor, not a description of you.
 
 ### Questions ride the same blackboard
@@ -321,4 +322,4 @@ the credential: **a receipt the audited party can mint is not a receipt** — wh
 door takes the human's own token and never a seat's job ticket.
 
 ## Lineage
-- **Related** — [docs-workflow](docs-workflow.md) · [doc-index](doc-index.md) · the `spec-parent` and `spec-seat` skills (the operational templates and the seat contract)
+- **Related** — [docs-workflow](docs-workflow.md) · [doc-index](doc-index.md) · the `spec-coordinator` and `spec-seat` skills (the operational templates and the seat contract)

package/skills/docs-process/SKILL.md

@@ -45,7 +45,8 @@ branch, which is the truth for that PR, and you say so at close.
    the seat that does it.
 
    **If the effort was a spec pipeline, you have a SECOND input: `sessions/code-review.md`** — the review
-   seat's outside look, filed beside `parent-retrospective.md`. Read both. **Every review finding gets a
+   seat's outside look, filed beside the coordinator's retrospective (`coordinator-retrospective.md`, or
+   `parent-retrospective.md` in an effort begun before that name). Read both. **Every review finding gets a
    disposition, and the disposition is TOTAL:** a living-doc patch here · an existing fixit seat · a
    chartered follow-up · a new spec pipeline · or killed on record with the reason. **A finding with no named
    home is dropped, not deferred** — and the review's own classification (fixit candidate / deferred /

package/skills/init/SKILL.md

@@ -250,5 +250,5 @@ write, offer — and ask before doing either — to fill each new absent-line fr
 - The floor four are always drafted, even in a repository with no frontend — the reading floor must
   RESOLVE for every seat kind, and "No frontend detected — fill this in" is an honest doc. The standard
   seven are drafted only on evidence; their absence is recorded, never papered over.
-- Counterpart skills: `spec-seat` (reads the floor), `spec-child` (reads the role rows), `spec-pipeline`
+- Counterpart skills: `spec-seat` (reads the floor), `spec-build` (reads the role rows), `spec-pipeline`
   (writes the brief `doctor` checks), `docs-write` / `docs-process` (the queue `doctor` reads).

package/skills/init/scripts/doctor.mjs

@@ -5,7 +5,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
-import { OWNED, compareVersions, compareMinor, frontmatterListCount, linesOf, bare, h2Index, findSection, railsItems } from './owned.mjs';
+import { OWNED, KINDS, KIND_SKILLS, NOT_SKILLS, skillTokens, compareVersions, compareMinor, frontmatterListCount, linesOf, bare, h2Index, findSection, railsItems } from './owned.mjs';
 
 const repo = resolve(process.argv[2] || process.cwd());
 const packRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
@@ -194,7 +194,9 @@ for (const name of ['CLAUDE.md', 'AGENTS.md']) {
 }
 
 // ── 7. every ignition brief, checked the way the control plane checks it ────────────────────────
-const KINDS = new Set(['coordinator', 'build', 'fixit', 'review', 'retro', 'witness', 'docs-process']);
+// The kick is sent verbatim as the coordinator's task, so a skill it names that this pack does not carry
+// (a renamed one, most often) tells the coordinator to invoke nothing.
+const packSkills = new Set(existsSync(join(packRoot, 'skills')) ? readdirSync(join(packRoot, 'skills')) : []);
 const researchDir = join(repo, 'docs', 'research');
 if (existsSync(researchDir)) {
   for (const topic of readdirSync(researchDir)) {
@@ -205,6 +207,7 @@ if (existsSync(researchDir)) {
     const kick = sectionOf(text, '## The kick');
     if (kick === null) problems.push('the brief has no `## The kick` section, so the task text could not be read');
     else if (!kick.split('\n').some((l) => l.trimStart().startsWith('>'))) problems.push('the `## The kick` section carries no blockquote; its whole text stands in for the task');
+    const unknown = kick === null || packSkills.size === 0 ? [] : [...new Set(skillTokens(kick))].filter((t) => !packSkills.has(t) && !NOT_SKILLS.includes(t));
     const seq = sectionOf(text, '## The sequence');
     if (seq === null) problems.push('the brief has no `## The sequence` section, so no seats could be read');
     else {
@@ -213,13 +216,14 @@ if (existsSync(researchDir)) {
       for (const line of tableRows.slice(1)) {
         const cells = line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim().replace(/^`|`$/g, '').trim());
         if (cells.every((c) => /^[-: ]*$/.test(c))) continue;
-        if (!cells.some((c) => KINDS.has(c))) { problems.push(`a sequence row names no seat kind and composes nothing: \`${line.trim()}\``); continue; }
+        if (!cells.some((c) => KINDS.includes(c))) { problems.push(`a sequence row names no seat kind and composes nothing: \`${line.trim()}\``); continue; }
         const spec = cells.map((c) => /\b(\d{2}-[A-Za-z0-9._-]*?\.md)\b/.exec(c)).find(Boolean);
         if (spec && !existsSync(join(researchDir, topic, spec[1]))) problems.push(`the sequence names \`${spec[1]}\` and it is missing from disk`);
       }
     }
-    if (problems.length) for (const pr of problems) row('FAIL', `docs/research/${topic}/00-ignition-brief.md`, pr);
-    else row('ok', `docs/research/${topic}/00-ignition-brief.md`, 'the kick and the sequence read clean');
+    for (const pr of problems) row('FAIL', `docs/research/${topic}/00-ignition-brief.md`, pr);
+    for (const t of unknown) row('DEGRADE', `docs/research/${topic}/00-ignition-brief.md`, `the kick names \`${t}\`, a skill this pack does not carry; the coordinator's skill is \`${KIND_SKILLS.coordinator}\``);
+    if (!problems.length && !unknown.length) row('ok', `docs/research/${topic}/00-ignition-brief.md`, 'the kick and the sequence read clean');
   }
 }
 

package/skills/init/scripts/owned.mjs

@@ -21,6 +21,32 @@ export const OWNED = [
 
 export const STAMP = /^(<!-- naswerks-loop: version=)([0-9]+\.[0-9]+\.[0-9]+[^ ]*)( -->)/;
 
+// The seat kinds a pipeline row may name, checked the way the control plane checks a brief's sequence.
+export const KINDS = ['coordinator', 'build', 'fixit', 'review', 'retro', 'witness', 'docs-process'];
+
+// The skill each kind runs as its job. A spec seat's skill is named for its kind, so a skill's name says
+// which seat runs it: `fixit` is the build job's no-spec variant, and `docs-process` is the knowledge
+// loop's own skill, seated by a pipeline as its last row.
+export const KIND_SKILLS = {
+  coordinator: 'spec-coordinator',
+  build: 'spec-build',
+  fixit: 'spec-build',
+  review: 'spec-review',
+  retro: 'spec-retro',
+  witness: 'spec-witness',
+  'docs-process': 'docs-process',
+};
+
+// Words shaped like a skill name that name no skill: the method doc, the placeholders, and the compounds
+// the prose uses. Every other spec-* or docs-* word the pack writes is a skill it carries.
+export const NOT_SKILLS = ['docs-workflow', 'spec-slug', 'spec-path', 'spec-doc', 'spec-driven', 'docs-only'];
+
+// Every skill-shaped word in a text. A word followed by `*` or `-*` names a family (docs-*, docs-audit-*),
+// never one skill.
+export function skillTokens(text) {
+  return [...text.matchAll(/\b(?:spec|docs)-[a-z]+(?:-[a-z]+)*\b(?![-*])/g)].map((m) => m[0]);
+}
+
 export function compareVersions(a, b) {
   const pa = a.split(/[.-]/).map((x) => parseInt(x, 10) || 0), pb = b.split(/[.-]/).map((x) => parseInt(x, 10) || 0);
   for (let i = 0; i < 3; i++) { if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) - (pb[i] || 0); }

package/skills/{spec-child → spec-build}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: spec-child
-description: The BUILD JOB for a pipeline seat — one spec, the role's reading list, the pin taxonomy, the suite protocol, and the fixit variant. Composed AFTER spec-seat, which carries the seat contract (blackboard, question lane, verdicts, FINAL TLDR, close-out). Use when a prompt says you are a build or fixit session, or run spec-child {role} {spec-path}. Roles: backend | frontend | mixed.
+name: spec-build
+description: The BUILD JOB for a pipeline seat — one spec, the role's reading list, the pin taxonomy, the suite protocol, and the fixit variant. Composed AFTER spec-seat, which carries the seat contract (blackboard, question lane, verdicts, FINAL TLDR, close-out). Use when a prompt says you are a build or fixit session, or run spec-build {role} {spec-path}. Roles: backend | frontend | mixed.
 ---
 
-# spec-child
+# spec-build
 
 **Your seat contract is `spec-seat` — invoke it first if you have not.** It carries the blackboard, the
 question lane, the parked-call discriminator, the verdict vocabulary, the BELIEFS sha, git shapes, the
@@ -14,7 +14,7 @@ You build exactly one spec. The coordinator judges and rules; you recon, plan, b
 Hand-cranked, a human relays messages; hosted inside a pipeline, your coordinator drives you itself and
 the relay is machine-carried — **your contract is identical either way.**
 
-Invoked as `spec-child {role} {spec-path}`, or told "you are a build session" with the spec path.
+Invoked as `spec-build {role} {spec-path}`, or told "you are a build session" with the spec path.
 
 ## Step 1 — with your role and spec in hand
 
@@ -130,7 +130,7 @@ build over a tree they had not touched, and they got a **passing receipt that pr
 false-green genus, embedded in the manual instead of in a test. Name the app you edited and run its
 commands from its root.
 
-## Fix-it variant (`spec-child fixit`)
+## Fix-it variant (`spec-build fixit`)
 
 No spec — your contract is the prompt + the coordinator's ledger (READ-ONLY). **STEP 0 — INVESTIGATE,
 REPORT, STOP:** (1) reproduce/characterize cheaply, (2) find the cheapest reliable RECEIPT for the fixed
@@ -152,6 +152,6 @@ what a truthful partial looks like per named item, **ask for it** before you sta
 - **The spec's anchors are hypotheses; HEAD is the truth.** The biggest catches — stale trees, false
   greens, dropped rulings — are all belief-vs-ledger mismatches. Your beliefs block exists so the
   coordinator can catch them cheaply.
-- Counterpart skills: `spec-seat` (your contract) · `spec-parent` (the seat that arms you) ·
+- Counterpart skills: `spec-seat` (your contract) · `spec-coordinator` (the seat that arms you) ·
   `spec-pipeline` (how your spec came to exist). The hosted version of you runs THIS same pair — the
   control plane's seed names both skills, in this order.

package/skills/{spec-parent → spec-coordinator}/SKILL.md

@@ -1,12 +1,12 @@
 ---
-name: spec-parent
-description: Assume the COORDINATOR seat for a spec-pipeline effort — quarterback the build seats (one per spec) via prompts, TLDR reviews, verification, and commit calls. Use immediately after spec-pipeline in the same session (the author is already context-loaded), or in a fresh session with the topic name to resume/take a prepped effort. Run spec-parent {topic}.
+name: spec-coordinator
+description: Assume the COORDINATOR seat for a spec-pipeline effort — quarterback the build seats (one per spec) via prompts, TLDR reviews, verification, and commit calls. Use immediately after spec-pipeline in the same session (the author is already context-loaded), or in a fresh session with the topic name to resume/take a prepped effort. Run spec-coordinator {topic}.
 ---
 
-# spec-parent
+# spec-coordinator
 
 Turn this session into the **coordinator** for a `docs/research/{topic}/` spec pipeline. This is
-phase 3 of the backlog model (`docs-backlog`, `spec-pipeline`, **`spec-parent`**, seats build,
+phase 3 of the backlog model (`docs-backlog`, `spec-pipeline`, **`spec-coordinator`**, seats build,
 `docs-process`).
 
 **Find the format first.** This repository writes its formats (the doc header and status words, where an effort is filed, its rails) in the sections `rg -n '^#+ .*\(repository-owned\)' docs/_meta/` lists; read the one a step names before that step writes. This skill names the section, never the format.
@@ -117,7 +117,7 @@ read the board and answer on first receipt rather than spending a round-trip.
    corrected.
 
    **Pick the docs:** the floor and the loop's standard docs are settled (`spec-seat`'s Step 0 +
-   `spec-child`'s role table). **This repository's own docs are yours to seed, by path, every time:** copy
+   `spec-build`'s role table). **This repository's own docs are yours to seed, by path, every time:** copy
    the seat's role rows from `docs/_meta/doc-index.md` § Role reading lists into the prompt's `EXTRA DOCS`
    line — a seat follows a path in its prompt and does not reliably follow an index. Then add the extras
    the task itself warrants. When in doubt, seed the doc: a seat reading one extra doc is cheaper than a
@@ -420,10 +420,12 @@ so read them as run-time obligations, not close-out ones:
   wait or to reshape the command — not to complete a run or curl past the fence. **And a park that sails
   through anyway is DATA:** record it immediately as an incident, because a fence that failed silently once
   will fail silently again, and your record is the only trace.
-- **`parallel:true` is for specs that share no files — that is its whole purpose.** A refused spawn means
-  the previous seat is still holding the shared effort worktree and needs reaping; the answer is to reap
-  it, or to wait if it has not closed out yet. Reaching for `parallel` there is a category error rather
-  than a shortcut: it does not free the worktree, it just puts two seats in it.
+- **A shared worktree holds one live seat at a time, and nothing but you enforces it.** `seat_spawn`
+  refuses a terminal seat, a seat that already has a live session and a runner it cannot reach — it does
+  NOT refuse a second seat while another is still live in the shared tree, so spawning early puts two
+  seats in one worktree. Reap the previous seat first, or wait if it has not closed out yet. Parallel
+  seats need separate worktrees, which is the pipeline's shape, decided at create — and only for specs
+  that share no files.
 
 ## The steering channel — shape your callouts by SOLICITATION
 
@@ -442,10 +444,10 @@ send context attached to a ruling instead.
 
 ## The seat prompt template
 
-The ceremony rides the **`spec-child` skill** — the prompt is an IGNITER, not a ceremony restatement.
+The ceremony rides the **`spec-build` skill** — the prompt is an IGNITER, not a ceremony restatement.
 
 ```
-You are a BUILD SEAT in a coordinator-run effort: invoke the spec-child skill with
+You are a BUILD SEAT in a coordinator-run effort: invoke the spec-build skill with
 role={backend | frontend | mixed} before anything else, and ALWAYS after `spec-seat`: the seat header
 names `spec-seat` first, the job skill second.
 
@@ -473,7 +475,7 @@ THE TASK: {compressed spec restatement with the load-bearing specifics inline.}
 
 For investigation-first work, add **STEP 0 — INVESTIGATE, REPORT, STOP** before the task, or use
 `role={...} fixit` for no-spec defect sessions (the skill carries the fix-it ceremony). Fallback: if the
-seat can't invoke skills, paste the ceremony from the `spec-child` skill inline.
+seat can't invoke skills, paste the ceremony from the `spec-build` skill inline.
 
 ### The bookend rows (R and P) get a MANIFEST instead of prior shapes
 
@@ -514,7 +516,7 @@ P it is the difference between archiving this effort and sweeping somebody else'
 ## Ruling template (plan review / question answers)
 
 ```
-PARENT RESPONSE — PLAN TLDR {ACCEPTED / ACCEPTED WITH RIDERS / BLOCKING-PRECONDITION}.
+COORDINATOR RESPONSE — PLAN TLDR {ACCEPTED / ACCEPTED WITH RIDERS / BLOCKING-PRECONDITION}.
 {Verdict vocabulary: accept · accept-with-riders (numbered rulings anchored to the SEAT'S OWN item
 numbers — it folds them in and GOES, no re-approval round-trip; the dominant verdict) ·
 blocking-precondition ("accept, but step 0 first") · read-full-plan (not a verdict you send — you
@@ -543,14 +545,17 @@ asking for a paste (`read-full-plan` = read `plan.md`, a pull, never force-fed).
 verbs ARE the appends and the machinery writes them for you.
 
 **Anchor grammar (canonical — the witness greps these):** rulings land under
-`## PARENT RULING (plan — {verdict})` hand-cranked, `## PARENT RULING (plan rev N — {verdict})` when the
-rev ladder exists; notes under `## PARENT NOTE ({context})`. The parent-voice vocabulary is a CLOSED list
-of four — `PARENT NOTE` · `PARENT ACCEPT` · `PARENT RULING` · `OPERATOR RULING` — so a fifth anchor you
-invent counts as nothing. **Never vary the prefixes**, and **never discuss the anchor grammar inside a
-steering note**: the detector matches the STRING, not your intent, and naming an anchor while explaining
-it derives a spurious acceptance receipt. Refer to it obliquely ("the acceptance anchor").
-**Point, don't paste:** steer with *"read your `tldr.md` under `## PARENT RULING`"*, never by re-pasting a
-multi-KB block into a composer.
+`## COORDINATOR RULING (plan — {verdict})` hand-cranked, `## COORDINATOR RULING (plan rev N — {verdict})`
+when the rev ladder exists; notes under `## COORDINATOR NOTE ({context})`. The coordinator-voice
+vocabulary is a CLOSED list of four — `COORDINATOR NOTE` · `COORDINATOR ACCEPT` · `COORDINATOR RULING` ·
+`OPERATOR RULING` — so a fifth anchor you invent counts as nothing. An older board spells the first three
+`PARENT NOTE` · `PARENT ACCEPT` · `PARENT RULING`; every reader of the anchors, each grep in this loop
+included, takes that spelling as the same three, and you write only the new one. **Never vary the prefixes**, and **never
+discuss the anchor grammar inside a steering note**: the detector matches the STRING, not your intent,
+and naming an anchor while explaining it derives a spurious acceptance receipt. Refer to it obliquely
+("the acceptance anchor").
+**Point, don't paste:** steer with *"read your `tldr.md` under `## COORDINATOR RULING`"*, never by
+re-pasting a multi-KB block into a composer.
 
 **When to read (hand-cranked):** the human's nudge is your wake signal, and the human is the ONLY bus — so
 before cutting each next prompt, sweep `sessions/*/tldr.md` mtimes for appends you were never nudged
@@ -564,7 +569,7 @@ plan-approval click is the human's counterpart of the product's accept-gate —
 ## Docs-write + commit call template
 
 ```
-PARENT RESPONSE — FINAL TLDR ACCEPTED {(+ what I verified myself)}.
+COORDINATOR RESPONSE — FINAL TLDR ACCEPTED {(+ what I verified myself)}.
 1. Run docs-write. Carry: {departures, honest gaps, deferred findings verbatim, gotchas}.
 2. COMMIT CALL — approved. Stage explicitly (never git add -A): YOUR diff + working doc,
    PLUS docs/research/{topic}/project-status.md — my ledger rides your commit,
@@ -583,7 +588,7 @@ PARENT RESPONSE — FINAL TLDR ACCEPTED {(+ what I verified myself)}.
 ```
 
 **THE ACCEPTANCE IS A RECEIPT VERB, AND PROSE IS NOT A RECEIPT.** Send the acceptance act carrying your
-text; it lands in the seat's `tldr.md` under `## PARENT ACCEPT (final — {slice})` and the rev-bound
+text; it lands in the seat's `tldr.md` under `## COORDINATOR ACCEPT (final — {slice})` and the rev-bound
 receipt derives from it. **An acceptance delivered as a steering note records zero rows** — and the push
 bar reads the row, not the paragraph.
 
@@ -591,10 +596,10 @@ bar reads the row, not the paragraph.
 (the receipt binds pre-commit), then the seat commits and pushes. **The receipt is rev-bound:** it covers
 the tldr rev + HEAD it was written against — if the seat re-posts its TLDR CONTENT after your acceptance,
 the unattended push parks naming both revs, and one **argless re-accept** is the cheap repair, **sent with
-the retry order in the same act**. A seat's post-push `## [child·…] CLOSE-OUT RECEIPT` append does NOT
+the retry order in the same act**. A seat's post-push `## [seat·…] CLOSE-OUT RECEIPT` append does NOT
 stale your acceptance — reap without a re-accept after it.
 
-**Hand-cranked:** append the same `## PARENT ACCEPT (final — {slice})` heading to the seat's
+**Hand-cranked:** append the same `## COORDINATOR ACCEPT (final — {slice})` heading to the seat's
 `sessions/{slug}/tldr.md` yourself — there is no machinery and no derivation; the anchor + your tracker
 row ARE the receipts.
 
@@ -617,7 +622,7 @@ post-merge.
   corrections, what you verified yourself, mid-build directives, and anything you don't want to forget —
   written when it happens, never reconstructed at close. **The tracker's own section notes say what each
   section holds**; follow them rather than inventing structure. Do **not** add a `## Checkpoint ledger` or
-  a `## Parent decisions` section — the session entry *is* the decision record, and a parallel section
+  a `## Coordinator decisions` section — the session entry *is* the decision record, and a parallel section
   splits one narrative across two places.
 - **If a retro has to supersede your session rows, the ledger was not kept.** A retro confirms the rows
   and adds the audit and economics; it never corrects facts that should already be written.
@@ -644,7 +649,7 @@ post-merge.
   a sequence, and do not treat a stale living doc as something this effort must fix.
 - Periodically remind the human to sweep your doc edits into a small `docs` commit.
 - Counterpart skills: `spec-seat` (the contract of every seat you arm — read it to know what they were
-  told) · `spec-child` (the builders' job skill) · `spec-pipeline` (how the specs came to exist) ·
+  told) · `spec-build` (the builders' job skill) · `spec-pipeline` (how the specs came to exist) ·
   `spec-review` (the outside look, before your retro) · `spec-retro` (your close-out audit) ·
   `spec-witness` (the read-only verifier) · `spec-ignite` (the ignition copilot that puts an authored
   effort onto the plane).

package/skills/spec-ignite/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: spec-ignite
-description: Become the IGNITION COPILOT for a spec pipeline — verify the committed ignition brief against live state, verify every step by receipt, and kick on the human's word. Authoring belongs to spec-pipeline; this seat VERIFIES, so it can run cold. Use right after spec-pipeline when the pipeline will run hosted (the manual alternative is spec-parent), or fresh with a topic whose specs are already authored. Two verbal gates: nothing moves before "stage it"; nothing spawns before "kick it".
+description: Become the IGNITION COPILOT for a spec pipeline — verify the committed ignition brief against live state, verify every step by receipt, and kick on the human's word. Authoring belongs to spec-pipeline; this seat VERIFIES, so it can run cold. Use right after spec-pipeline when the pipeline will run hosted (the manual alternative is spec-coordinator), or fresh with a topic whose specs are already authored. Two verbal gates: nothing moves before "stage it"; nothing spawns before "kick it".
 ---
 
 # spec-ignite
@@ -119,10 +119,10 @@ injects** — the human keyboard and the hardened ladders are the only submit pa
 
 The coordinator's task is the brief's own **`## The kick`** section, copied verbatim. Roughly:
 
-> You are the COORDINATOR of the {topic} pipeline. Invoke the `spec-parent` skill, then read
+> You are the COORDINATOR of the {topic} pipeline. Invoke the `spec-coordinator` skill, then read
 > `docs/research/{topic}/00-ignition-brief.md` and follow it. Your branch is `{the effort's branch}`.
 
-**Do not draft a constitution here.** The seat's PROCEDURE is the `spec-parent` skill; its POLICY rides the
+**Do not draft a constitution here.** The seat's PROCEDURE is the `spec-coordinator` skill; its POLICY rides the
 un-skippable policy suffix the control plane supplies at open (you do not paste it, and you cannot
 override it); its HANDS are the coordinator charter the control plane attaches to a `coordinator` seed
 and to no other kind. This RUN's choreography is the committed brief. A task string cannot be diffed or
@@ -271,7 +271,7 @@ you found rather than working around it.
   anomalies that may change it — surprises are findings, not adjustments.
 
 ## Related
-- `spec-pipeline` (authors what you ignite, including the brief you verify) · `spec-parent` (the
-  coordinator's procedure, and the HAND-CRANKED alternative) · `spec-seat` + `spec-child` (what the
+- `spec-pipeline` (authors what you ignite, including the brief you verify) · `spec-coordinator` (the
+  coordinator's procedure, and the HAND-CRANKED alternative) · `spec-seat` + `spec-build` (what the
   control plane seeds into every build seat) · `spec-retro` (the close-out audit) · `spec-witness`
   (point one at the run you just ignited)

package/skills/spec-pipeline/SKILL.md

@@ -59,14 +59,14 @@ sessions/                        WHO PUTS IT THERE
                                  questions with the coordinator's rulings appended beneath them. Read
                                  top-to-bottom it IS the session's whole conversation, in message order
   code-review.md                 the review seat, in its own commit, if the run has a review row
-  parent-retrospective.md        the coordinator, at the close
+  coordinator-retrospective.md   the coordinator, at the close
   witness-ledger-*.md            a human commit — the witness is zero-writes by contract (its ticket
                                  cannot even carry the write scope), so its testimony reaches the repo
                                  by someone else's hand
 ```
 
 - **Per-seat artifacts go in a `{spec-slug}/` subfolder; effort-wide artifacts sit at the `sessions/`
-  root.** The first seat creates its subfolder and, incidentally, the parent folder; everything after
+  root.** The first seat creates its subfolder and, incidentally, `sessions/` itself; everything after
   writes into what exists.
 - **RE-COPY BOTH FILES ONCE, IMMEDIATELY BEFORE THE FINAL PUSH.** A seat's close-out receipt is written
   AFTER the commit that carries its testimony, so a single copy always lands truncated — and a follow-up
@@ -78,7 +78,7 @@ sessions/                        WHO PUTS IT THERE
   separate questions file, and there are no status snapshots: the tracker is committed live, so its git
   history already carries the progression a snapshot would fake.
 - **Append-only.** `tldr.md` grows; nobody rewrites it. The rev ladder is the history.
-- **Who READS it:** the coordinator reads each TLDR and appends its rulings under `## PARENT RULING` · the
+- **Who READS it:** the coordinator reads each TLDR and appends its rulings under `## COORDINATOR RULING` · the
   review seat reads every session's TLDR as testimony **and reads nothing else** · the retro greps it for
   acceptance anchors and unanswered questions · the witness uses rev counts and mtimes as a zero-cost
   heartbeat.
@@ -214,7 +214,7 @@ sessions/                        WHO PUTS IT THERE
 5. **Name the archive destination when only you can.** Read `docs/_meta/docs-workflow.md` § The archive
    convention (repository-owned). If where a pipeline files depends on something only this session knows
    (which living feature the effort belongs to, say), resolve it now and write the path into the
-   umbrella's blockquote as an `Archive:` line; `spec-parent` hands it to the docs-process row and
+   umbrella's blockquote as an `Archive:` line; `spec-coordinator` hands it to the docs-process row and
    `docs-process` files there. A convention that needs nothing from you needs no line.
 
 6. **Stop.** The specs stay in `research/{topic}/`. Do NOT implement, do NOT touch living docs, do NOT
@@ -320,7 +320,7 @@ cross-reading them; a human row recorded only by the coordinator has ONE, and th
 one whose errors nobody else catches.
 
 ## The kick — paste this verbatim as the coordinator's task
-> You are the COORDINATOR of the {topic} pipeline. Invoke the `spec-parent` skill, then read
+> You are the COORDINATOR of the {topic} pipeline. Invoke the `spec-coordinator` skill, then read
 > `docs/research/{topic}/00-ignition-brief.md` and follow it. Your branch is `{the effort's branch}`.
 
 Deltas true of THIS kick only (a concurrent pipeline, a model override, a one-off probe) go here as a
@@ -328,7 +328,7 @@ short list. Everything else is already in this brief — the task string is a PO
 stays short because a task buried in a run row cannot be diffed or reviewed the way this file can.
 ```
 
-**Do not restate the ceremony here.** The coordinator's procedure lives in `spec-parent` and its policy
+**Do not restate the ceremony here.** The coordinator's procedure lives in `spec-coordinator` and its policy
 is the one § This repository's rails (repository-owned) names, which a hosted run also carries in the
 un-skippable policy suffix the control plane supplies; a brief that re-teaches them accretes
 into prompt-law that breaks the coordinator it was meant to steer. The brief carries THIS RUN's
@@ -410,7 +410,7 @@ viewer because they are instructions to the coordinator, not content for the hum
 |---|---|---|---|
 ```
 
-**Never generate a `## Checkpoint ledger` or a `## Parent decisions` section.** The session section
+**Never generate a `## Checkpoint ledger` or a `## Coordinator decisions` section.** The session section
 *is* the decision record; a parallel section splits one narrative across two places.
 
 ## `live-checks.md`

package/skills/spec-retro/SKILL.md

@@ -13,8 +13,8 @@ today that perspective evaporates the moment the run closes. This skill turns it
 **Find the format first.** This repository writes its formats (the doc header and status words, where an effort is filed, its rails) in the sections `rg -n '^#+ .*\(repository-owned\)' docs/_meta/` lists; read the one a step names before that step writes. This skill names the section, never the format.
 
 Run it as the **last act of the coordinator seat**, after the final session's close-out commit — before or
-after the PR is cut, either works. Output: `docs/research/{topic}/sessions/parent-retrospective.md`. It is
-a scoped write on the pipeline's branch, so it rides the PR to the base branch either way.
+after the PR is cut, either works. Output: `docs/research/{topic}/sessions/coordinator-retrospective.md`.
+It is a scoped write on the pipeline's branch, so it rides the PR to the base branch either way.
 
 **You are one of the three kinds that do NOT compose `spec-seat`** — this skill is your whole contract,
 and the control plane's seed says so rather than merely omitting it.
@@ -54,7 +54,7 @@ document** — a number whose lane you cannot name is testimony, not an audit.
 
 **If the argless sweep is not runnable at your run's scale, that is a day-one escalation, not a
 close-out discovery.** A few thousand rows can exceed the lane's page budget; you cannot retroactively
-obtain the audit your own doctrine mandates. `spec-parent` carries this as a run-time obligation.
+obtain the audit your own doctrine mandates. `spec-coordinator` carries this as a run-time obligation.
 
 **Two instruments that share no code are the only way a ceremony audit means anything** — on one
 instrument you are grading your own homework with your own pencil. Where the control plane offers a
@@ -148,11 +148,13 @@ could not tell. And do not flatten predicates that were measured apart: a conten
 stales a PUSH; a close-out-receipt append does not stale a REAP. Report what you observe; never
 generalise one park into a law.
 
-**The derived-row path:** the acceptance's durable record is the `## PARENT ACCEPT (final — {slice})`
-anchor in each seat's `tldr.md`, and the receipt DERIVES from it. Reconcile file against substrate:
+**The derived-row path:** the acceptance's durable record is the `## COORDINATOR ACCEPT (final —
+{slice})` anchor in each seat's `tldr.md`, and the receipt DERIVES from it. A board written before this
+vocabulary spells it `## PARENT ACCEPT`; a reader of the anchors takes both spellings, so the grep does too. Reconcile
+file against substrate:
 
 ```bash
-rg -n "## PARENT ACCEPT" docs/research/{topic}/sessions/*/tldr.md
+rg -n "## (COORDINATOR|PARENT) ACCEPT" docs/research/{topic}/sessions/*/tldr.md
 ```
 
 **AUDIT THE QUESTION LANE THE SAME WAY — it is a heading grep, not a row query.** A seat asks by appending
@@ -163,8 +165,8 @@ run whose seats asked repeatedly and changed a ruling by it.
 **AND ON THE HOSTED PLANE THE FILE IS NOT THE CLOSE PREDICATE — audit BOTH halves, because they answer
 different questions.** *Was one asked?* is a fact about the file (the heading grep below, mirroring the
 control plane's grammar). *Was it answered?* is a fact about the LEDGER — the ruling act carrying the
-asking post's id — and it is deliberately not read from the file, because a seat can type a parent-voice
-heading into its own blackboard. **A retro that audits only the file can be shown a question that
+asking post's id — and it is deliberately not read from the file, because a seat can type a
+coordinator-voice heading into its own blackboard. **A retro that audits only the file can be shown a question that
 answered itself.** Reconcile the grep's hits against the ruling acts, and report any hit with no act as an
 unanswered question whatever the file says.
 
@@ -177,11 +179,12 @@ prefixed and plural headings, and the lane has TWO headings: `## QUESTIONS` (rec
 rg -niE '^##[[:space:]]*(\[[^]]*\][[:space:]]*)?(MID-BUILD[[:space:]]+)?QUESTIONS?\b' docs/research/{topic}/sessions/*/tldr.md | rg -viE 'QUESTIONS?[[:space:]]+ANSWERED'
 ```
 
-Reconcile each hit against the parent-voice append that answered it (`## PARENT RULING` / `## PARENT NOTE`
-in the same file) — an unanswered question is the finding. **Your audit instrument must be at least as
-tolerant as the code it audits.**
+Reconcile each hit against the coordinator-voice append that answered it (`## COORDINATOR RULING` /
+`## COORDINATOR NOTE` in the same file, or `## PARENT RULING` / `## PARENT NOTE` on an older board) — an
+unanswered question is the finding. **Your audit instrument must be at least as tolerant as the code it
+audits.**
 
-- **Hosted:** N `## PARENT ACCEPT` anchors imply N acceptance acts (rev-bound: the act carries the tldr
+- **Hosted:** N acceptance anchors (`## (COORDINATOR|PARENT) ACCEPT`) imply N acceptance acts (rev-bound: the act carries the tldr
   rev, the HEAD and a content hash). An anchor with no act means the derivation failed (LOUD in the
   logs — find it); an act with no anchor is a cockpit accept (legitimate; the act says so).
   Acceptance-shaped PROSE without the anchor writes nothing by design — flag it as a ceremony miss.
@@ -374,7 +377,7 @@ is the look of a record with none of a record's properties.
    session's `tldr.md`, and the working docs.
 2. **Query** the substrate for §§2-5. Verify each query FIRES on a known-positive row before trusting a
    clean result.
-3. **Write** `docs/research/{topic}/sessions/parent-retrospective.md` — NATIVELY, in the tree you were born
+3. **Write** `docs/research/{topic}/sessions/coordinator-retrospective.md` — NATIVELY, in the tree you were born
    in: the coordinator lives in the effort's worktree, so the scoped write (the effort home's own `.md`
    files, `sessions/`, the tracker, `live-checks.md` and the specs) lands on the effort's branch and rides
    its PR. Every write earns its loud audit row. **If the write REFUSES, that is a PLATFORM DEFECT:**
@@ -396,6 +399,6 @@ is the look of a record with none of a record's properties.
    leaves an identical belief standing in a sibling that words it differently has to be made twice.
 
 ## Related
-- `spec-parent` (the seat, and the run-time half of this skill's close-out demands) · `spec-child` (the
-  builders) · `spec-seat` (their shared contract) · `spec-witness` (the read-only verifier) ·
+- `spec-coordinator` (the seat, and the run-time half of this skill's close-out demands) · `spec-build`
+  (the builders) · `spec-seat` (their shared contract) · `spec-witness` (the read-only verifier) ·
   `spec-pipeline` (which authored the specs you are grading)

package/skills/spec-review/SKILL.md

@@ -24,7 +24,7 @@ else's job.
   Reading it anchors you on that grade and the pipeline pays for two opinions to get one.
 - **You do not fix anything.** Findings get classified and filed. A reviewer that repairs its own findings
   cannot be trusted to count them.
-- **You do not decide whether a fixit runs — you classify.** The parent rules on it. A reviewer that can
+- **You do not decide whether a fixit runs — you classify.** The coordinator rules on it. A reviewer that can
   trigger work is grading its own necessity.
 - **Every TLDR, spec, and doc claim is TESTIMONY to verify, never a fact to build on.** That includes
   anything your coordinator tells you: if a ruling arrives in your `tldr.md`, record it and treat it as a
@@ -194,8 +194,9 @@ testimony.
 
 ## The report — `sessions/code-review.md`
 
-Files beside `parent-retrospective.md` in the pipeline's `sessions/` folder. It is a pipeline artifact,
-not a chat transcript, and it archives with the effort.
+Files beside the coordinator's retrospective in the pipeline's `sessions/` folder
+(`coordinator-retrospective.md`, or `parent-retrospective.md` in an effort begun before that name). It is
+a pipeline artifact, not a chat transcript, and it archives with the effort.
 
 ```markdown
 # Code + session review — {topic}, pipeline {id}
@@ -244,7 +245,7 @@ that does not exist yet (an unauthored row, an unwritten charter) is NOT homed:
 
 ## Lineage   _(where § Doc metadata (repository-owned) keeps the footer)_
 - **Pipeline** — the tracker · the umbrella · sessions 02..NN
-- **Counterpart** — `parent-retrospective.md` (the inside look; written after this)
+- **Counterpart** — `coordinator-retrospective.md` (the inside look; written after this)
 ```
 
 ## Ceremony
@@ -254,7 +255,7 @@ TLDR with beliefs and numbered questions, the question lane, the parked-call dis
 vocabulary, the six-section FINAL TLDR, and the close-out order. You commit `sessions/code-review.md` on
 your coordinator's call like any seat.
 
-**The close-out receipt's heading token is the literal `child·` for you too** — it is a protocol anchor,
+**The close-out receipt's heading token is the literal `seat·` for you too** — it is a protocol anchor,
 not a description of your seat, and writing `[review·…]` stales your own acceptance. `spec-seat` carries
 the detail.
 
@@ -267,7 +268,7 @@ Your baselines are reads, not builds: you run the suites to confirm the pipeline
 number you cannot reproduce is a finding.
 
 ## Related
-- `spec-parent` (rules on your fixit candidates; writes the retro after you) · `spec-child` (the seats you
+- `spec-coordinator` (rules on your fixit candidates; writes the retro after you) · `spec-build` (the seats you
   are reviewing) · `spec-retro` (the inside look) · `spec-witness` (the live read-only seat; its ledger, if
   one exists, is evidence like any other artifact) · `docs-process` (consumes this report and gives every
   finding a disposition)

package/skills/spec-seat/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: spec-seat
-description: The CONTRACT for any seat a pipeline coordinator arms — the blackboard, the question lane, the parked-call discriminator, the verdict vocabulary, the BELIEFS sha, git shapes, the six-section FINAL TLDR, and the close-out order. Invoked FIRST, then the job skill (spec-child | spec-review | docs-process). Not a seat of its own; the shared half of every seat's procedure.
+description: The CONTRACT for any seat a pipeline coordinator arms — the blackboard, the question lane, the parked-call discriminator, the verdict vocabulary, the BELIEFS sha, git shapes, the six-section FINAL TLDR, and the close-out order. Invoked FIRST, then the job skill (spec-build | spec-review | docs-process). Not a seat of its own; the shared half of every seat's procedure.
 ---
 
 # spec-seat
@@ -10,13 +10,13 @@ the review row, the docs-process row — runs THIS, then its own job skill:
 
 | Seat kind | Composes |
 |---|---|
-| `build` · `fixit` | `spec-seat` + **`spec-child`** |
+| `build` · `fixit` | `spec-seat` + **`spec-build`** |
 | `review` | `spec-seat` + **`spec-review`** |
 | `docs-process` | `spec-seat` + **`docs-process`** |
 
 **THE PAIRING IS SEVEN-WAY AND NON-UNIFORM, and the three kinds missing from that table are missing
 DELIBERATELY.** `coordinator`, `retro` and `witness` each carry their OWN whole contract
-(`spec-parent` · `spec-retro` · `spec-witness`) and are **never** told to invoke this file — prefixing
+(`spec-coordinator` · `spec-retro` · `spec-witness`) and are **never** told to invoke this file — prefixing
 `spec-seat` onto a skill that already carries a whole contract ships a seed contradicting the skill it
 points at. The control plane composes each kind's seed from this table and has no catch-all: an unknown
 kind is refused by name (`seat-kind-has-no-seed`) rather than ignited wrongly.
@@ -26,7 +26,7 @@ contradicts it. Where they genuinely conflict, that is **a finding to report**,
 quietly — say so in your PLAN TLDR and let the coordinator rule.
 
 **The coordinator does NOT compose this.** It writes rulings rather than receiving them, owns the tracker,
-and holds the close — a different contract, and `spec-parent` carries it whole.
+and holds the close — a different contract, and `spec-coordinator` carries it whole.
 
 **Why this file exists:** a base contract that every seat kind shared, with the build job mixed in, sent
 the review row into the umbrella its own charter excluded and offered the docs-process row a `docs-write`
@@ -100,7 +100,7 @@ FINAL TLDR — **append, never overwrite**) are FILES, not just chat text.
 
 - **Hand-cranked:** create them under `docs/research/{topic}/sessions/{slug}/` at plan time and end your
   turn announcing the path. The coordinator reads `tldr.md` with normal file tools and APPENDS its ruling
-  under `## PARENT RULING`, so read the answer in your own file and proceed. The full plan is PULL — it is
+  under `## COORDINATOR RULING`, so read the answer in your own file and proceed. The full plan is PULL — it is
   read only on a read-full-plan verdict; never paste it into chat. (If your harness has a plan-approval
   mode that forbids writes: give the chat summary, get the human's approve, THEN post and stop.)
 - **Hosted (a seat inside a pipeline):** the same two files are yours to edit with normal file tools, then
@@ -118,29 +118,33 @@ Either way, `tldr.md` read top-to-bottom is the session's whole conversation in
 
 **Greppable turn anchors:** every append gets a stable heading carrying actor + identity —
 `## [{seat}·{slug} · run {id}] {phase}` when your seat has a run identity, `## [{seat}·{slug}] {phase}`
-hand-cranked. The coordinator's voice is always `## PARENT RULING …` / `## PARENT NOTE …`. The stable
-prefixes are the contract: one grep for `## PARENT RULING` across every session's `tldr.md` lists every
-ruling in the effort.
-
-**THE HEADING VOCABULARY IS CLOSED, AND THAT IS THE HAZARD AS WELL AS THE CONTRACT.** The parent-voice
-list is exactly four — `PARENT NOTE` · `PARENT ACCEPT` · `PARENT RULING` · `OPERATOR RULING` — matched
-by the control plane on a word boundary, so `## PARENT NOTEBOOK` cannot pass. A fifth anchor invented
-later closes nothing and counts as nothing until the control plane learns it. **Section boundaries are
-level-2 headings only** — `### Option A` inside your question block is still inside the question,
-deliberately, so a ruling never arrives having truncated your options.
-
-**Point, don't paste:** to direct anyone at content, say *"read `tldr.md` under `## PARENT RULING`"* —
-never re-paste a multi-KB block into a composer.
+hand-cranked. The coordinator's voice is always `## COORDINATOR RULING …` / `## COORDINATOR NOTE …`. The
+stable prefixes are the contract: one grep for `## (COORDINATOR|PARENT) RULING` across every session's
+`tldr.md` lists every ruling in the effort.
+
+**THE HEADING VOCABULARY IS CLOSED, AND THAT IS THE HAZARD AS WELL AS THE CONTRACT.** The
+coordinator-voice list is exactly four — `COORDINATOR NOTE` · `COORDINATOR ACCEPT` · `COORDINATOR RULING`
+· `OPERATOR RULING` — matched by the control plane on a word boundary, so `## COORDINATOR NOTEBOOK`
+cannot pass. An older board spells the first three `PARENT NOTE` · `PARENT ACCEPT` · `PARENT RULING`; a
+reader of the anchors takes that spelling as the same three, which is why the grep above carries both. A fifth
+anchor invented later closes nothing and counts as nothing until the control plane learns it. **Section
+boundaries are level-2 headings only** — `### Option A` inside your question block is still inside the
+question, deliberately, so a ruling never arrives having truncated your options.
+
+**Point, don't paste:** to direct anyone at content, say *"read `tldr.md` under `## COORDINATOR
+RULING`"* — never re-paste a multi-KB block into a composer.
 
 **If `tldr.md` already exists when you go to create your blackboard, APPEND** — machinery may have written
-before you, and recreating the file clobbers it (the platform refuses a shrinking rewrite).
+before you, and recreating the file clobbers it (the platform refuses a shrinking rewrite). **And every
+heading already on your board stays exactly as written, an older spelling included:** the platform refuses
+a revision whose earlier headings changed, so never tidy an old heading into the current vocabulary.
 
 **Re-read `tldr.md` immediately before every append.** The coordinator appends into the SAME file between
 your turns — an edit whose old text no longer matches almost always means the conversation moved.
 Re-read, fold what's new, then append. Never resolve the mismatch by rewriting the whole file; the rev
 ladder is the history.
 
-**`## PARENT NOTE (FYI — no reply needed)` is the NO-TURN lane:** the coordinator can leave you
+**`## COORDINATOR NOTE (FYI — no reply needed)` is the NO-TURN lane:** the coordinator can leave you
 informational context WITHOUT waking you — it lands durably in your `tldr.md` and costs you nothing.
 The re-read above is where you pick FYIs up: fold them as context, owe no reply, and never treat one as
 a ruling — an FYI cannot answer an open question (only a ruling heading does).
@@ -149,7 +153,7 @@ a ruling — an FYI cannot answer an open question (only a ruling heading does).
 
 **When you need a decision at ANY point:** append a question section to your own `tldr.md`, post
 (`post_tldr`), and **END YOUR TURN.** Your coordinator is woken with your text, and its ruling under a
-parent-voice heading is your answer — pick it up from your own file and resume.
+coordinator-voice heading is your answer — pick it up from your own file and resume.
 
 **TWO literal headings, one lane — pick by phase, and use a real `##` heading either way:**
 
@@ -170,7 +174,7 @@ every section and answers `Blocking` / `NotBlocking` / `Undeclared`. Markdown ar
 - **Never let a reader turn your declaration into liveness.** It is a claim made at the instant you
   typed it; a seat that wrote `BLOCKING:` and then kept working was telling the truth.
 
-**Both poke the coordinator identically** — same wake, same re-raise, same parent-voice answer. The split
+**Both poke the coordinator identically** — same wake, same re-raise, same coordinator-voice answer. The split
 is for the READER (a recon fork and a mid-build discovery are different kinds of news), never for the
 machinery. A question under any OTHER heading — or as a bare `QUESTIONS:` label with no `##` — gets no
 banner and **the re-raise can never fire**, so it can sit unanswered indefinitely. And never use
@@ -194,13 +198,13 @@ the pipeline a round-trip and nothing else.
 The latch reads the ACTS LEDGER: a ruling closes your question only when it is delivered as a `callout`
 carrying your post's act id as `answeringActId`. A `callout` without one steers you and closes nothing.
 **The reason is a security property, not tidiness:** `tldr.md` is written BY YOU, so a file-side close
-predicate is a string the audited party can type — a seat could write `## PARENT RULING` into its own file
+predicate is a string the audited party can type — a seat could write `## COORDINATOR RULING` into its own file
 and switch off the very re-raise that exists to stop it waiting forever. The question is therefore split
 in two: *was one asked?* — a fact about the file, where forgery only wakes your own coordinator — versus
 *was it answered?* — a fact about what the coordinator DID, read from the ledger.
 
 **The honest rendering of your file is unchanged**: an open-questions read of the file still clears on the
-parent-voice heading, because that is what the file SAYS. What differs is what a DECISION may be
+coordinator-voice heading, because that is what the file SAYS. What differs is what a DECISION may be
 predicated on.
 
 ### THREE CONTRACT LINES, all earned by one kind of silence
@@ -238,7 +242,7 @@ Ask what the park is protecting:
 
 - **A park on a STATE condition** — the park text names a rev, a hash, or a version: it is STATE, not
   approval. Do not re-request, do not reshape; read the substrate for the healing signal (your own acts:
-  the fresh acceptance receipt, or the `## PARENT NOTE (re-accept)` append) and retry ONCE on receipt.
+  the fresh acceptance receipt, or the `## COORDINATOR NOTE (re-accept)` append) and retry ONCE on receipt.
   State parks are machine-healable — one argless re-accept re-binds a stale acceptance. **Never hold for
   one specific lane: whichever arrives first IS your signal, and the substrate outranks the bus.**
 - **A park on your own legitimate in-worktree work** — **re-request it** (no self-imposed cap, no
@@ -342,7 +346,7 @@ naming both. That is why your BELIEFS sha is a contract line and not a courtesy
 moves mid-build is disclosed FIRST, never absorbed quietly.
 
 **The re-accept signal:** after a rev-bound/stale-acceptance park, the re-accept arrives as a
-`## PARENT NOTE (re-accept)` append plus a callout — retry your held action on receipt. If your next wake
+`## COORDINATOR NOTE (re-accept)` append plus a callout — retry your held action on receipt. If your next wake
 shows the fresh acceptance receipt in your own rows WITHOUT the note, **that row IS your signal** — the
 substrate outranks the bus. Never hold for one specific lane. **A re-accept with no retry order is a
 doorbell with no follow-through**; if you receive one bare, retry anyway and say that you did.
@@ -416,13 +420,13 @@ produces a working doc**, COMMIT CALL with the message). Execute it exactly.
 makes the acceptance stale by design. Append your close-out receipt AFTER the push under this heading:
 
 ```
-## [child·{slug} · run {id}] CLOSE-OUT RECEIPT
+## [seat·{slug} · run {id}] CLOSE-OUT RECEIPT
 ```
 
 ## IF YOU HAVE PUSHED AND ARE WAITING, SAY SO. IT DOES NOT STALE YOU.
 
 ```
-## [child·{slug} · run {id}] HOLDING
+## [seat·{slug} · run {id}] HOLDING
 ```
 
 **Then `post_tldr` and end your turn.** Body: what you pushed, and what you are waiting for
@@ -437,10 +441,11 @@ cost a pipeline hours. Preventing it is your job, and it costs you one append.
 the accepted CONTENT, not to the revision number, so appending your own state or a question leaves it
 intact. Only **new content** stales.
 
-**The token is the literal `child·`, whatever seat you are.** The control plane's close-out matcher keys
-on `[child·…] CLOSE-OUT RECEIPT`, so a review or docs-process seat that writes `[review·…]` or
+**The token is the literal `seat·`, whatever seat you are.** The control plane's close-out matcher keys
+on `[seat·…] CLOSE-OUT RECEIPT`, so a review or docs-process seat that writes `[review·…]` or
 `[process·…]` **fails the match and stales its own acceptance** — costing a re-post and an argless
-re-accept. **It is a PROTOCOL ANCHOR, not a description of you.** A descriptive tail after the marker IS
+re-accept. (An older board's `[child·…]` token matches too; write only `seat·`.) **It is a PROTOCOL
+ANCHOR, not a description of you.** A descriptive tail after the marker IS
 blessed (`… CLOSE-OUT RECEIPT — addendum: the six staged, tree clean`) — an end-anchored pattern on the
 one heading seats are told to write would be a trap that fires on ordinary prose.
 
@@ -489,7 +494,7 @@ why. Silence is not compliance.
 **THE TESTIMONY REGRESS, AND THE DECLARED STOPPING POINT — read this before you copy anything.** The
 order above puts the COMMIT before the CLOSE-OUT RECEIPT, so the copy you commit ends at your FINAL TLDR
 and can contain neither the receipt (hash, session id, staging receipt) nor the coordinator's
-`## PARENT ACCEPT`. **A follow-up commit does not fix this, it moves it:** any receipt ABOUT that commit is
+`## COORDINATOR ACCEPT`. **A follow-up commit does not fix this, it moves it:** any receipt ABOUT that commit is
 also written after it. The regress is infinite and the ceremony does not pretend otherwise.
 
 **So the rule is a declared stopping point rather than a fix: RE-COPY `plan.md` AND `tldr.md` ONCE,
@@ -519,5 +524,5 @@ plane. The publish receipt is written at your turn's STOP and is structurally un
   with a clean rerun builds trust, an undisclosed one destroys it.
 - **A rule recalled from context needs re-reading at the source before it is used to refuse work.** A
   rule already corrected on disk is the commonest thing a seat blocks itself on.
-- Your job skill is next: `spec-child` (build/fixit) · `spec-review` (the outside look) ·
-  `docs-process` (compile the living docs). Counterpart: `spec-parent` (the seat that arms you).
+- Your job skill is next: `spec-build` (build/fixit) · `spec-review` (the outside look) ·
+  `docs-process` (compile the living docs). Counterpart: `spec-coordinator` (the seat that arms you).

package/skills/spec-witness/SKILL.md

@@ -78,13 +78,16 @@ git — agree.
    are a zero-token heartbeat per seat — a growing ladder is a live session, a frozen one dates its last
    turn. `seat_content` reads the board; read `tldr.md` top-to-bottom and it IS the session's whole
    conversation in message-flow order — the fastest "where is this seat" there is. The coordinator's
-   voice is a greppable anchor: `## PARENT RULING (plan rev N — {verdict})` and `## PARENT NOTE (…)`
-   (actor-suffixed when known) on the hosted plane; the same prefixes without the rev counter under
-   `docs/research/{topic}/sessions/{spec-slug}/` hand-cranked — so grep the prefix, never the full form.
+   voice is a greppable anchor: `## COORDINATOR RULING (plan rev N — {verdict})` and `## COORDINATOR NOTE
+   (…)` (actor-suffixed when known) on the hosted plane; the same prefixes without the rev counter under
+   `docs/research/{topic}/sessions/{spec-slug}/` hand-cranked — so grep the prefix, never the full form,
+   and grep both spellings: an older board writes `## PARENT RULING` / `## PARENT NOTE`
+   (`rg -n "## (COORDINATOR|PARENT) (RULING|NOTE)"`).
    **Honest delivery verdicts:** a ruling act's reply states recorded-vs-delivered truthfully —
    "recorded, not delivered" is NORMAL (the seats run substrate-first; the board is load-bearing, the
    pointer is best-effort). A delivery miss is only a finding if the seat ALSO never acted on the
-   substrate. **Blessed close-outs:** a seat's post-push `## [child·…] CLOSE-OUT RECEIPT` append does NOT
+   substrate. **Blessed close-outs:** a seat's post-push `## [seat·…] CLOSE-OUT RECEIPT` append (an older
+   board's `[child·…]`) does NOT
    stale its acceptance — a reap without a fresh acceptance after such an append is correct behaviour,
    not a skipped step.
 3. **Change-detection monitors, not tails:** emit only rows past a high-water mark + a terminal-state
@@ -216,7 +219,7 @@ Disciplines that don't fit a numbered step:
   trusting their silence — silence from a dead monitor looks identical to a quiet run.
 
 ## Related
-- `spec-parent` (the seat that rules) · `spec-child` (the seats that act) · `spec-seat` (their shared
+- `spec-coordinator` (the seat that rules) · `spec-build` (the seats that act) · `spec-seat` (their shared
   contract — read it to know what the seats you are watching were told)
 - **You are one of the three kinds that do NOT compose `spec-seat`** — this skill is your whole
   contract, and the control plane's seed says so rather than merely omitting it.

package/templates/docs/_meta/doc-index.md

@@ -54,7 +54,7 @@
 
 ## Role reading lists
 
-The docs a build seat reads on top of the floor every seat reads (`spec-seat` Step 0). The `spec-child`
+The docs a build seat reads on top of the floor every seat reads (`spec-seat` Step 0). The `spec-build`
 skill names the loop's standard docs by path; this table is the repository's reserved space — one row per
 doc, saying which roles read it. The coordinator copies a role's rows into every seat's seed as
 `EXTRA DOCS`, so a seat sees paths, not this index. Add a row for any doc of your own a role should read;