@naswerks/engineering-loop 0.8.0 → 0.9.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.8.0",
+      "version": "0.9.0",
       "source": "./"
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "naswerks",
-  "version": "0.8.0",
+  "version": "0.9.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,100 @@ version is the one in `package.json` and `.claude-plugin/plugin.json`, which mus
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-11-14
+
+A minor: the skills act differently, the doctor can newly fail a brief, and a repository's copy of the loop text
+takes one paragraph (§ Upgrading from 0.8). A pipeline that writes one repository runs as it did.
+
+### Added
+
+- **A seat may also write a second repository: the `Repository` column.** A sequence row names the repositories its
+  seat also writes in, in an optional `Repository` column: one or more names, as the runner serves them. The column
+  never moves a seat: its home is the pipeline's own repository, where its spec, its board and the tracker are, and
+  one pull request still closes the pipeline. `spec-pipeline` states the column. `init doctor` reads it the way a
+  launcher does, and fails a cell holding a kind word, `step`, a name that is not one path segment of at most 200
+  characters, a ninth name, or a name twice. **A pipeline that writes one repository has no such column and is
+  unchanged.**
+- **What a seat does in a second repository** (`spec-seat` § Git shapes, `spec-build`). Its home stays this
+  repository and nothing of the pipeline's record is written in the other one. Its code goes in its own tree of
+  that repository, never the owner's checkout: hosted, at the path the variable its seed names holds; by hand, at
+  the path its prompt names. Then a staging list, a `verify-staged` receipt, a commit and a push per repository;
+  that repository's whole gate, run in its tree; its own rules for commit and pull-request text; a draft pull
+  request where it checks them, its checks read after every push; no merge, tag or publish. Its commit there goes
+  on an `ALSO WRITING` line beneath BELIEFS, and its FINAL gives a list and a receipt per repository. A pin holds
+  every clause, because a launcher that knows this version says only where the tree is.
+- **The push in a second repository has its own form:** `cd` into the tree, then the push, and nothing else on the
+  line. `spec-seat` said a leading `cd` disqualifies every push; that is the rule for the home repository, and it
+  now says so.
+- **The coordinator's and the review's side of a second repository.** `spec-coordinator` tells such a seat where
+  its tree is and nothing else (by hand; hosted, the seed says where), diffs its `ALSO WRITING` line, checks two
+  receipts at the FINAL, reads a pull request's checks at every seat report in whichever repository the branch is,
+  and hands the review one diff range per repository (by release tags when the run released it mid-run).
+  `spec-review` reads each range and the seam between them. A pin holds every template line for a further
+  repository under a line saying when it applies.
+- **A conditional fixit that must write a further repository is listed as a row, directly after the review row**
+  (`spec-pipeline`). Listed anywhere else, a launcher reads a second fixit beside the one the review implies, and
+  the doctor names it.
+- **The model and the effort a run starts on are named in the brief and read back.** `spec-pipeline`'s `## Birth`
+  names both, each in backticks, because the launcher reads them from that section; a brief that names neither
+  leaves both to the launcher's default. A seat's BELIEFS line states the model and effort its session is running
+  on, as it can read them, and `spec-coordinator` settles a seat on a pair the brief does not name before it rules
+  that seat's plan.
+
+### Changed
+
+- **Pipelines never intertwine** replaces "one pipeline at a time", in `spec-coordinator`'s hard rules and in
+  `references/engineering-loop.md`. A brief's GATE still checks only that its predecessor merged, and no seat waits
+  on another pipeline; independent pipelines may run at the same time, each on its own branch. The coordinator takes
+  a moved base branch in between seats, by a merge. A repository's `docs/_meta/` copy takes the paragraph by hand.
+- **A review's diff range reads the remote's copy of the base branch** (`origin/{base}...{branch}`), in
+  `spec-coordinator`'s REVIEW manifest, `spec-review` and `spec-pipeline`: a local base branch can sit behind it and
+  pull another effort's commits into the range.
+- **`spec-coordinator`'s Step 0 is two numbered reads:** the seven floor docs, then every doc the repository's role
+  reading lists carry a path for. The second read was a trailing clause, and coordinators read the floor and stopped.
+  The status readback opens with how many docs each read took.
+- **The coordinator edits its tracker and a seat's board with file tools, never a shell heredoc or an interpreter
+  one-liner** (`spec-coordinator`): one collapses backslashes, and one whose text quotes a publish is held.
+
+### Fixed
+
+- `spec-coordinator` said a backticked sha is fine for the plan verdict's workspace HEAD. The verb takes only the
+  bare 40-hex sha and refuses a backticked or quoted one, recording nothing, so a coordinator that followed the skill
+  spent a refused call on every plan ruling. It now says the bare sha; a seat's board may still fence its own.
+- `spec-coordinator` wrote an amount as a dollar sign before a digit, which a harness that substitutes a skill's
+  arguments by position rewrote at load: the line about uncosted turns read with the invocation's first argument in
+  the amount's place. The amount is spelled out, and a pin holds every skill's text free of a dollar sign before a
+  digit and of the arguments token.
+- `spec-seat`, `spec-coordinator` and `spec-retro` said the gate matches text and told a seat to keep git words out
+  of echo labels, section headers and searches. The gate reads the command the shell would run: what parks is the
+  operation, at any depth, and an echo label, a branch listing and a quoted search are data unless something on the
+  line could run them. Six passages say so now, in fewer lines, and a pin keeps the old rule out.
+- `spec-seat` said the HEAD check takes the first `HEAD <sha>` it meets. It reads the newest line that carries
+  `BELIEFS`, so a seat whose HEAD moved appends a new BELIEFS line and never edits the old one.
+
+### Upgrading from 0.8
+
+In this order:
+
+1. **Take the release where every session loads it:** `claude plugin marketplace update engineering-loop`, then
+   `claude plugin update naswerks@engineering-loop --scope <scope>` for each scope that runs sessions, and a new
+   session. A runner takes `@naswerks/engineering-loop@0.9.0` in the folder its plugin directories name, and is
+   restarted by its owner with no seat live.
+2. **Replace one paragraph of loop text.** In `docs/_meta/engineering-loop.md`, the paragraph that opens
+   **One pipeline at a time.** becomes:
+
+   > **Pipelines never intertwine.** A pipeline's GATE is that its predecessor merged — never a seat of another
+   > pipeline — and no seat waits on another pipeline. Independent pipelines may run at the same time, each on
+   > its own branch, merged one after the other.
+
+   It is the only loop text that changed. `docs/_meta/docs-workflow.md` takes nothing but its stamp, and the four
+   repository-owned sections are yours and are not touched.
+3. **Restamp and check:** `init refresh` (with `--write`) restamps both copies and leaves every other line as it
+   is; then `init doctor`. A repository that read clean on 0.8.0 reads clean, unless a brief lists a `fixit` row
+   away from its `review` row or holds a `Repository` cell that is not a list of names.
+
+No pipeline folder changes shape, and a sequence with no `Repository` column reads as it always has.
+
 ## [0.8.0] - 2026-10-21
 
 A minor: the skills act differently, and a repository must act — its method docs take new text, and every

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naswerks/engineering-loop",
-  "version": "0.8.0",
+  "version": "0.9.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.8.0 -->
+<!-- naswerks-loop: version=0.9.0 -->
 # Docs Workflow
 
 > How knowledge flows through `docs/`: the loop, the folder rules, the templates, and the `docs-*` skills.

package/references/engineering-loop.md

@@ -1,4 +1,4 @@
-<!-- naswerks-loop: version=0.8.0 -->
+<!-- naswerks-loop: version=0.9.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-*`
@@ -74,8 +74,9 @@ owner's — never a seat's job and never a doc's row: the coordinator offers a s
 the chat, and `live-checks.md` holds only the rows the owner dictates. Everything between `idea` and
 `archived` a pipeline can do for itself.
 
-**One pipeline at a time.** A pipeline's GATE is that its predecessor merged — never a seat of another
-pipeline — and the next one starts after it.
+**Pipelines never intertwine.** A pipeline's GATE is that its predecessor merged — never a seat of another
+pipeline — and no seat waits on another pipeline. Independent pipelines may run at the same time, each on
+its own branch, merged one after the other.
 
 **`docs-audit-*` is never a pipeline row.** It runs off-hours and scheduled, over the whole doc tree — not
 inside an effort, and not at an effort's close. A stale living doc is not something a pipeline must stop for.

package/skills/init/scripts/doctor.mjs

@@ -197,6 +197,11 @@ for (const name of ['CLAUDE.md', 'AGENTS.md']) {
 // 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')) : []);
+// A repository's name as a sequence row may write it: one path segment, no separators, no spaces, of at most
+// MAX_REPOSITORY_NAME characters; a row names at most MAX_REPOSITORIES, none twice.
+const REPOSITORY_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const MAX_REPOSITORY_NAME = 200;
+const MAX_REPOSITORIES = 8;
 const researchDir = join(repo, 'docs', 'research');
 if (existsSync(researchDir)) {
   for (const topic of readdirSync(researchDir)) {
@@ -217,17 +222,38 @@ if (existsSync(researchDir)) {
       const cellsOf = (line) => line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim().replace(/^`|`$/g, '').trim());
       // The optional Role column, found by its header; a row's cell there is a role or empty.
       const roleAt = tableRows.length ? cellsOf(tableRows[0]).findIndex((c) => c.toLowerCase() === 'role') : -1;
+      // The optional Repository column, found by its header; a row's cell there names the repositories the
+      // seat also writes in, or is empty. The table is read by kind value, so a kind word or `step` in that
+      // cell would be read as the row's kind: it fails by name, before either is looked for.
+      const repositoryAt = tableRows.length ? cellsOf(tableRows[0]).findIndex((c) => c.toLowerCase() === 'repository') : -1;
+      // The seat rows' kinds, in order: where a listed fixit sits is read from them.
+      const seatKinds = [];
       for (const line of tableRows.slice(1)) {
         const cells = cellsOf(line);
         if (cells.every((c) => /^[-: ]*$/.test(c))) continue;
         const spec = cells.map((c) => SPEC_FILE.exec(c)).find(Boolean);
         if (spec) named.add(spec[1]);
+        const repositories = repositoryAt >= 0 ? (cells[repositoryAt] ?? '') : '';
+        const names = !repositories || /^[-—]$/.test(repositories) ? [] : repositories.split(/\s*[·,]\s*/).map((n) => n.replace(/`/g, '').trim()).filter((n) => n !== '');
+        const notNames = names.filter((n) => KINDS.includes(n) || n === STEP || !REPOSITORY_NAME.test(n) || n.length > MAX_REPOSITORY_NAME);
+        if (notNames.length) {
+          for (const n of notNames) problems.push(`a sequence row's repository \`${n.length > 60 ? `${n.slice(0, 60)}…` : n}\` is not a repository's name (one path segment of at most ${MAX_REPOSITORY_NAME} characters; a kind word or \`${STEP}\` there is read as the row's kind): \`${line.trim().slice(0, 200)}\``);
+          continue;
+        }
+        if (names.length > MAX_REPOSITORIES) problems.push(`a sequence row names ${names.length} repositories and a seat writes at most ${MAX_REPOSITORIES}: \`${line.trim()}\``);
+        for (const n of new Set(names.filter((name, i) => names.indexOf(name) !== i))) problems.push(`a sequence row names the repository \`${n}\` twice: \`${line.trim()}\``);
         if (cells.includes(STEP)) continue;
         if (!cells.some((c) => KINDS.includes(c))) { problems.push(`a sequence row names no seat kind and composes nothing (a row that is not a seat says \`${STEP}\`): \`${line.trim()}\``); continue; }
+        seatKinds.push(cells.find((c) => KINDS.includes(c)));
         const role = roleAt >= 0 ? (cells[roleAt] ?? '') : '';
         if (role && !/^[-—]$/.test(role) && !ROLES.includes(role)) problems.push(`a sequence row's role \`${role}\` is not one of ${ROLES.map((r) => `\`${r}\``).join(' · ')}: \`${line.trim()}\``);
         if (spec && !existsSync(join(researchDir, topic, spec[1]))) problems.push(`the sequence names \`${spec[1]}\` and it is missing from disk`);
       }
+      // A listed fixit is the one its review implies only when it is the next seat row after that review. Listed
+      // anywhere else, a launcher reads a second fixit beside the implied one, and that one names no repository.
+      const reviewAt = seatKinds.indexOf('review');
+      const fixitAt = seatKinds.indexOf('fixit');
+      if (reviewAt >= 0 && fixitAt >= 0 && fixitAt !== reviewAt + 1) problems.push('the sequence lists a `fixit` row that is not the next seat row after its `review` row, so a launcher reads two fixits and the extra one names no repository: move the row directly after the review');
     }
     // An old-shape folder carries an umbrella: a `01-` file no sequence row names. It still runs on an older
     // pack; carry it over before it runs on this one.

package/skills/spec-build/SKILL.md

@@ -93,6 +93,10 @@ signal that a VERDICT changed, not that the test is stale.
 Run the suite lanes **SERIALLY** — the lanes and their exact invocations are `patterns/testing.md`
 § Running tests; concurrent runs flake.
 
+**A seat that wrote a further repository runs THAT repository's gate too, inside its tree of it** — the
+lanes its own contributing rules name, serially, never beside this repository's — and reports each
+repository's summaries under its own name. This repository's lanes do not run the code you wrote there.
+
 **Capture FULL runner output to a UTF-8 file and search failures by name** — redirect to a file, then
 search `^failed ` / `Failed!`. Piping through a "last N lines" filter destroys failure names.
 

package/skills/spec-coordinator/SKILL.md

@@ -35,14 +35,15 @@ hand-testing what shipped. Everything else that a human does hand-cranked, you d
 
 ## Read first
 
-**Step 0 — the same floor every seat reads, all seven, plus every standard doc this repository has.**
-You verify every seat's work, so you start from the context they build in. A coordinator that has not
-read `testing.md` cannot judge a receipt; one that has not read `codegen.md` (when the repo has one)
-cannot spot a hand-written generated file.
+**Step 0 — two reads, and neither is optional.** You verify every seat's work, so you start from the
+context they build in. A coordinator that has not read `testing.md` cannot judge a receipt; one that has
+not read `codegen.md` (when the repo has one) cannot spot a hand-written generated file.
 
-`_meta/doc-index.md` · `_meta/docs-workflow.md` · `_meta/engineering-loop.md` ·
-`patterns/code-organization.md` · `patterns/backend-patterns.md` · `patterns/frontend-patterns.md` ·
-`patterns/testing.md` — then every doc `doc-index.md` § Role reading lists carries a path for.
+1. **The floor every seat reads, all seven:** `_meta/doc-index.md` · `_meta/docs-workflow.md` ·
+   `_meta/engineering-loop.md` · `patterns/code-organization.md` · `patterns/backend-patterns.md` ·
+   `patterns/frontend-patterns.md` · `patterns/testing.md`.
+2. **Then every doc `doc-index.md` § Role reading lists carries a path for.** Open that section and read
+   each one. The floor alone is not Step 0.
 
 **Step 1 — the effort**, in order:
 
@@ -67,8 +68,9 @@ now, and again before you cut the retro. **A disagreement is a finding, not a ty
 changed in one place and not the other. Say which is right, fix the other, and journal it.
 
 Then produce a **5-line status readback** — shipped / in flight / next action / next prompt you expect to
-cut. Hand-cranked that goes to the human so they can confirm the seat transferred; hosted it is your
-opening journal entry in `project-status.md`, which is how anyone watching the cockpit catches up.
+cut — opening with how many docs each of Step 0's two reads took. Hand-cranked that goes to the human so
+they can confirm the seat transferred; hosted it is your opening journal entry in `project-status.md`,
+which is how anyone watching the cockpit catches up.
 
 **Same-session graduation:** you just ran `spec-pipeline`, so you already hold most of Step 1 — confirm
 the tracker exists and cut Prompt #1. **Step 0 still applies.**
@@ -88,7 +90,7 @@ plus the human relay.
 | Verb | What it does | The part that bites |
 |---|---|---|
 | `seat_spawn` | Opens a DECLARED sibling's session | **It can never CREATE a seat** — the topology is the create door's, decided by a human — and you may only drive seats you `supervises`/`reviews`. With no `hostId` it opens on the host carrying your own session; `model` and `effort` override the seat's own for this session, judged against what the runner offers |
-| `accept_plan` | The verdict act: `accept` · `accept-with-riders` · `blocking-precondition`, **and NOTHING ELSE carries a go** — and it DELIVERS ITSELF: the seat's live session receives a one-line pointer to the ruling, for an accepting verdict and for any verdict that filed a ruling in the seat's file | Write the ruling into the seat's `tldr.md` FIRST (`## COORDINATOR RULING (plan rev N — {verdict})`), then call with a one-line `ruling`: the file is mirrored before your act and the pointer names your section. Pass the workspace HEAD you observed (a backticked sha is fine); an accepting verdict whose seat planned against a different tree is REFUSED, naming both shas. READ THE REPLY'S `delivery:` and `file:` LINES — `NOT DELIVERED` means the seat is idle and only a `callout` reaches it. When the verdict also answers the seat's question, pass `answeringActId` — one act rules and closes it |
+| `accept_plan` | The verdict act: `accept` · `accept-with-riders` · `blocking-precondition`, **and NOTHING ELSE carries a go** — and it DELIVERS ITSELF: the seat's live session receives a one-line pointer to the ruling, for an accepting verdict and for any verdict that filed a ruling in the seat's file | Write the ruling into the seat's `tldr.md` FIRST (`## COORDINATOR RULING (plan rev N — {verdict})`), then call with a one-line `ruling`: the file is mirrored before your act and the pointer names your section. Pass the workspace HEAD you observed as the bare 40-hex sha `git rev-parse HEAD` prints — a backticked or quoted one is refused and records nothing, though a seat's board may fence its own; an accepting verdict whose seat planned against a different tree is REFUSED, naming both shas. READ THE REPLY'S `delivery:` and `file:` LINES — `NOT DELIVERED` means the seat is idle and only a `callout` reaches it. When the verdict also answers the seat's question, pass `answeringActId` — one act rules and closes it |
 | `accept` | The rev-bound FINAL receipt — and it TELLS the seat, so it carries your commit call | Put the next instruction (commit, push, close-out) in `ruling`, or write it under `## COORDINATOR ACCEPT` in the seat's `tldr.md` first — the receipt then binds to that mirrored revision. It binds to the seat's CURRENT tldr revision, so if the seat posts NEW CONTENT again your acceptance no longer covers what it publishes. **Re-accept — it is idempotent and cheap.** This receipt is what the push bar reads; prose is not a receipt. `answeringActId` closes the question it answers, as on `accept_plan` |
 | `complete` | The reap, and it is HONEST | It re-reads the seat and reports ok only after the terminal state is OBSERVED |
 | `callout` | **THE ONLY WAY YOU REACH A CHARGE** (besides the pointers `accept_plan` and `accept` send) | A charge that posted and ended its turn cannot resume any other way — without this verb it waits for a human. Your ruling must carry a DETERMINATE NEXT ACTION it can execute without inference. **Write it into the seat's `tldr.md` first and pass a one-line `ruling`:** the file is mirrored before your act and the seat is pointed at your section. Without a file, KEEP IT TO A LINE: over 600 chars the body is stored as a `ruling` artifact on the board and the seat receives a POINTER — the seat reads the body once, never twice |
@@ -171,6 +173,8 @@ and a seat's close-out. Never reconstruct it at the close.
    call out / hand the human both sides when the call is genuinely theirs.
    **The accepting verdict carries the workspace HEAD you observed, and a seat that planned against a
    different tree is REFUSED with both shas named.** So read the BELIEFS sha before you rule, not after.
+   **A seat whose row names a further repository states that tree too,** on an `ALSO WRITING` line beneath
+   its BELIEFS: diff its commit and branch against that repository's branch, with your own `git` read of it.
    **AND GRADE THE `CONTROLS` LINE — it is a required PLAN TLDR field and you are its only reader.** For
    every probe or pin the seat plans, it must name the positive control and what would make it FAIL. A
    missing or hand-wavy `CONTROLS` line is a rider, not a nit: a control that cannot fail is a green light
@@ -188,6 +192,8 @@ and a seat's close-out. Never reconstruct it at the close.
    But spot-check the riskiest claim yourself (never trust self-reported "N green"), and **verify your own
    rulings were APPLIED** — a ruling can silently drop, and a seat can rebuild the exact problem
    the ruling solved. Diff the shipped behavior against your ruling list before accepting.
+   **A seat that wrote two repositories returns two of everything:** a staging list and its receipt per
+   repository, and each repository's gate under its own name. A green in one says nothing about the other.
    **VERIFY THE CLAIM WHOSE FAILURE WOULD BE SILENT; MACHINE-COMPARE THE REST.** That is the rule that
    keeps your own share of the spend honest — a seat producing receipts that reconcile arithmetically has
    already done the work you would be repeating.
@@ -202,6 +208,10 @@ and a seat's close-out. Never reconstruct it at the close.
    **Advance the tracker AT EVERY CHECKPOINT.** Plan accepted: the row says so; final TLDR accepted: the
    row says so; push confirmed: SHIPPED with the hash. A stale tracker is your omission.
 
+   **WHEN A BRANCH A SEAT PUSHES HAS A PULL REQUEST OPEN, READ ITS CHECKS AT EVERY SEAT REPORT,** in
+   whichever repository it is, with your own read and not the seat's sentence about it: a check read at
+   the first commit says nothing about the tenth.
+
    **CLOSING A HUMAN STEP: TAKE THE RECEIPT, DO NOT WRITE IT.** A `step` row has no seat to post a TLDR,
    so the temptation is to transcribe the sitting into your tracker and call the step recorded. **That
    leaves it with ONE voice — yours — and it is the only row in the effort with one.** Ask the human
@@ -330,9 +340,7 @@ and a seat's close-out. Never reconstruct it at the close.
       `docs/_meta/engineering-loop.md` § This repository's rails (repository-owned) says (when it names no
       route, ask the human once and suggest recording the answer there); if one is already open the push is
       enough. These are your own git — gated and receipted like any other publish. **The
-      push command must be the ENTIRE command** (a leading `cd` disqualifies it), and keep git-verb words
-      out of any echo label around it — the deny layer matches TEXT, not parsed verbs, and a decorative
-      `=== remote tip ===` header over a read-only block will park.
+      push command must be the ENTIRE command** (a leading `cd` disqualifies it).
    6. **Report the close:** commits, receipts, total cost with its uncosted-turn count, the findings ledger,
       and the explicit list of what the human still owns. **The merge is theirs, never yours.**
    7. **If the effort has a DOCS-PROCESS row, it runs last** — after the PR exists, as its own session,
@@ -397,7 +405,7 @@ so read them as run-time obligations, not close-out ones:
 - **Verify a query FIRES on a known-positive before you trust a clean result.** A silently-empty result
   is usually a broken query, not an empty table — and a false all-clear on an audit query is worse than
   no query.
-- **Costs: uncosted turns count $0**, so any total is a FLOOR while the uncosted-turn count is above zero.
+- **Costs: an uncosted turn counts as nothing**, so any total is a FLOOR while the uncosted-turn count is above zero.
   Report it with the count. **Never sum across instruments** — session footers ride the seats' wakes and
   omit your own spend.
 
@@ -409,8 +417,10 @@ so read them as run-time obligations, not close-out ones:
   approved seat commits and pushes its branch itself (the relay, below); hosted, the commit call rides your
   acceptance. The PR is yours at the close. The merge is the human's, always. Explicit staging only —
   never `git add -A` — and never a push to the base branch.
-- **One pipeline at a time.** A brief's GATE checks only that its predecessor merged; never gate a run on
-  another pipeline's seats, and never run two pipelines over one another.
+- **Pipelines never intertwine.** A brief's GATE checks only that its predecessor merged; never gate a run
+  on another pipeline's seats, and never make a seat wait on one. Independent pipelines may run at the same
+  time, each on its own branch; never two over the same files or on one branch. When the base branch moves
+  under your run, take it in between seats, by a merge, never under a live seat and never as a rebase.
 - **Never advise or run a runner restart while a seat is live.** A restart ends every live session on that
   runner, and the plane may not notice. "Restarting it is fine" said to the human in that state is how a
   run loses every seat at once; say instead which seats are live and that the restart waits.
@@ -426,9 +436,9 @@ so read them as run-time obligations, not close-out ones:
 - **The unattended git form, and it binds YOU as much as the seats: one git command per call, no shell
   metacharacters.** The FORM check reads the whole command string, so chaining, redirects or substitution
   disqualify it — `git add … && git commit … && git push …` parks, while the same three sent separately
-  flow. Pushes always name the refspec; a push without one parks by design. Keep git-verb words out of
-  echo text and section labels — **including `branch`**, which parks a read-only branch LISTING on the
-  branch-deletion backstop. The fence fires on the commands a careful seat runs to PROVE its work.
+  flow. Pushes always name the refspec; a push without one parks by design. The gate reads the command
+  the shell would run, not its words: an echo label or a quoted search naming a git verb is data, unless
+  a shell or an interpreter is on the same line.
 - Seats never edit `project-status.md`, `live-checks.md` or memory files; never run `docs-write` unprompted;
   respect the brief's § What this effort does NOT do; codegen only through the command `patterns/codegen.md` § Running codegen
   names (when the repo has one); component files laid out as `patterns/frontend-patterns.md` § Component files states. Run the
@@ -438,9 +448,11 @@ so read them as run-time obligations, not close-out ones:
 - **Cite symbols, not bare `file:line`.** In a seed, a ruling, or the tracker, name the symbol and use the
   line as a hint — a line number is a comment, not an address, and the seat documenting why a line matters
   is what moves it.
-- Model policy: seats run **the effort's declared default model** (allowlist-exact, set at creation);
-  investigation-heavy sessions may warrant a reasoning-heavier one. Parallel sessions only when
-  the specs share no files — and sequence the *commits* regardless.
+- Model policy: seats run **the effort's declared default model and effort** — the pair the brief's
+  `## Birth` names (allowlist-exact, set at creation); investigation-heavy sessions may warrant a
+  reasoning-heavier one. **A seat's BELIEFS line states the pair it started on, and one the brief does not
+  name is settled before you rule its plan:** re-open the seat on the named pair, or rule the difference in
+  by name. Parallel sessions only when the specs share no files — and sequence the *commits* regardless.
 - **The gate is inverted (means are free, protocol is law):** benign tools/methods flow with audit rows;
   only the ceremony's boundaries park — in EVERY tier, recon included. Reads, execs, suites, pipes,
   redirects and in-worktree writes all flow pre-accept. **Do not seed tool-avoidance rules the platform
@@ -507,6 +519,9 @@ role={backend | frontend | mixed} before anything else, and ALWAYS after `spec-s
 names `spec-seat` first, the job skill second.        <- hand-cranked only; hosted, start at the spec
 
 Your spec: {absolute path to the spec}
+{only when the seat's row names a further repository, one line each; hand-cranked only — hosted, the
+ seed says where:}
+You also write: {repository} — your tree of it is {absolute path}, on branch {branch}. Never its owner's checkout.
 Pipeline context: {brief path} — the charter: its sections down to § Platform state bind you, and the owner's
 rulings in it are settled (don't relitigate) + {project-status.md path}
 (READ-ONLY, coordinator-owned — prior rows, deferred findings, and process incidents are your contract).
@@ -529,6 +544,10 @@ Baselines (cite, don't re-measure): {per lane, from the brief's § Baselines: N
 THE TASK: {compressed spec restatement with the load-bearing specifics inline.}
 ```
 
+**A seat that also writes a further repository is told WHERE, and nothing else about it:** what it does
+there is `spec-seat` § Git shapes, and a prompt that restates it is a second copy of the contract. A seat
+whose row names none gets no such line, and a prompt exactly as it would have been.
+
 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-build` skill inline.
@@ -546,7 +565,10 @@ second** — this is the whole point of the row.
 ```
 REVIEW row (R):
   You are the REVIEW SEAT: invoke the spec-review skill before anything else.
-  Topic: {topic} · branch: {branch} · diff range: {base}...{branch}
+  Topic: {topic} · branch: {branch} · diff range: origin/{base}...{branch}
+  {when the run wrote a further repository, one more line each:}
+  Also: {repository}, at {its path} · diff range: origin/{its base}...{its branch}, or by its release
+    tags ({the release before}...{this run's release}) when the run released it mid-run
   The brief, down to § Platform state and never past it (read as claims, not facts):
     docs/research/{topic}/00-ignition-brief.md
   Specs (read as claims, not facts): {every numbered spec path}
@@ -687,7 +709,9 @@ post-merge.
 - **The tracker is the seat — ONE ledger, and you write it live.** `project-status.md` is your journal: you
   own it, you advance it at every boundary, and the human never edits it. That file, not the chat, is the
   product of this skill. **The mechanism is ordinary file tools** — edit it exactly as a seat edits
-  `tldr.md`/`plan.md`; the gate permits the path. Git commits are the receipt: timestamped, attributed,
+  `tldr.md`/`plan.md`; the gate permits the path. **Never a shell heredoc or an interpreter one-liner,
+  for the tracker or for a seat's board:** one collapses backslashes in what it writes, and one whose
+  text quotes a publish is held as if it ran it. Git commits are the receipt: timestamped, attributed,
   carrying the diff.
 - **The session entry is a JOURNAL entry, not a status cell.** The ruling *and its reasoning*, recon
   corrections, what you verified yourself, mid-build directives, and anything you don't want to forget —

package/skills/spec-pipeline/SKILL.md

@@ -141,15 +141,27 @@ sessions/                        WHO PUTS IT THERE
    reading list of a build seat should not be left to the default. Leave the column out when no row needs
    it.
 
+   **A seat row may name the repositories it ALSO writes in** — in a `Repository` column, when the seat
+   builds something that lives in another repository: a package this repository consumes, say. The cell
+   holds one or more names, as the runner that carries the seat serves them, separated by ` · ` or `,`;
+   an empty cell, `-` or `—` means none. **The column never moves a seat:** its home is always the
+   pipeline's own repository, where the specs, the boards and the tracker are. The pipeline still closes
+   on ONE pull request, its own repository's; a release of the other repository is a `step` row. Leave
+   the column out when no row needs it — most pipelines write one repository, and nothing about them
+   changes.
+
    Then write the rows into the brief's sequence, in this order:
 
    ```
    0        the coordinator, with the brief as its spec
    01..NN   the build seats, with any `step` rows in their places
-   {R}      REVIEW      — spec-review, if chosen. Runs on `git diff {base}...<branch>` (the rails' base branch); no PR yet
+   {R}      REVIEW      — spec-review, if chosen. Runs on `git diff origin/{base}...<branch>` (the rails' base branch); no PR yet
    {F}      FIXIT       — MAY materialise, one maximum, only if the review classifies an (a)+(b)
                           finding AND the coordinator rules it in. Not authored up front; the
-                          coordinator charters it from the review's named list
+                          coordinator charters it from the review's named list. Listed as a row
+                          only when it must write a further repository: then directly after the
+                          review row, with its `Repository` cell — anywhere else a launcher reads
+                          a second fixit beside the one the review implies
    —        the coordinator's retro + PR (its own close-out, not a row)
    {P}      DOCS-PROCESS — if chosen
    ```
@@ -272,9 +284,15 @@ corrects drift; it does not re-author it.
 What is wrong today and what the effort makes true — the vision a seat builds toward.
 
 ## Birth
-Topic · spec path · receipt prefix · mode (hosted, or by hand) · shape · the effort's branch · the rows
-chosen at authoring (review? docs-process?) and why · **the GATE**: only that the predecessor merged, then
-re-verify this brief's § Reference and re-measure § Baselines.
+Topic · spec path · receipt prefix · mode (hosted, or by hand) · shape · the effort's branch · **the model
+and the effort every seat starts on** · the rows chosen at authoring (review? docs-process?) and why ·
+**the GATE**: only that the predecessor merged, then re-verify this brief's § Reference and re-measure
+§ Baselines.
+
+**Name the model and the effort, each in backticks** — the word model then the id, the word effort then the
+level (*every seat starts on model `{id}` at effort `{level}`*) — because the launcher reads both from this
+section. Write the id as the runner's catalog offers it. A brief that names neither leaves both to the
+launcher's default; hand-cranked, the same line tells the human which model to open each seat's session on.
 
 ## The sequence
 | Seat | Spec | Kind | Why it sits here |
@@ -285,7 +303,10 @@ prose role.** This table is READ, not just read by people: ignition derives the
 (`spec-ignite` § the stage card is derived), the create door validates the kind against a closed set and
 refuses an unknown by name, and the doctor fails a row whose kind is none of these. A cell saying "the one
 that reviews" composes nothing. An optional `Role` column carries `backend` · `frontend` · `mixed` for a
-seat whose reading list should not be left to the default.
+seat whose reading list should not be left to the default. An optional `Repository` column names the
+repositories a seat also writes in, by the runner's names; a seat's home is always this repository. Neither
+column's cell may hold a kind word or `step`: the table is read by kind value, and a kind word anywhere in
+a row is read as that row's kind.
 
 **This is the only copy of the sequence.** The tracker's status lines name these rows by id and copy
 nothing else.

package/skills/spec-retro/SKILL.md

@@ -73,9 +73,10 @@ population or only its failures.
   silently-empty result is usually a broken query, not an empty table.
 - **A search that times out is not a search that found nothing.** If a sweep backs an ABSENCE claim,
   re-run it on the tool that completes before you report the absence.
-- **A gate scanner matches TEXT.** A query or command whose text contains `git` and `push`, or
-  `git` + `branch` + a `-d` flag, parks by design. **Reshape the command — never re-request it.** (The
-  boundary half of `spec-seat`'s discriminator.)
+- **The gate reads the command the shell would run, not its words.** A quoted search pattern naming a
+  boundary operation is data; the same words handed to an interpreter, or carrying a substitution, are read
+  as something that could run, and park. **Reshape the command — never re-request it.** (The boundary half
+  of `spec-seat`'s discriminator.)
 
 **READS ONLY. Never write to the platform's store.**
 
@@ -393,8 +394,7 @@ is the look of a record with none of a record's properties.
    § This repository's rails (repository-owned) says (when it names no route, ask the human once and suggest
    recording the answer there); one branch, one PR from any seat. **If one is already open, the push is enough.** These three git commands are your own close-out
    lane and they are gated and receipted like any other publish. **The push command must be the ENTIRE
-   command** — a leading `cd` disqualifies it — and keep git-verb words out of any echo label you write
-   around it; the deny layer matches TEXT, not parsed verbs.
+   command** — a leading `cd` disqualifies it.
 6. **Sweep for stale beliefs BY MEANING, NEVER BY PHRASE — and sweep the SIBLINGS that restate a rule, not
    just the rule's own home.** A sweep keyed on wording only finds the wording it thought of. Ask what each
    instruction *depends on being true* — which file it names, which lane it assumes exists, who it thinks

package/skills/spec-review/SKILL.md

@@ -35,9 +35,12 @@ else's job.
 Your seed carries **no beliefs about the pipeline, and that is deliberate** — but it should carry an
 **inventory**, because you cannot review what you cannot find:
 
-- the **topic**, the **branch**, and the **diff range** (`{base}...<branch>` — `{base}` is the base branch
-  `docs/_meta/engineering-loop.md` § This repository's rails (repository-owned) names, or the remote's
-  default when it names none);
+- the **topic**, the **branch**, and the **diff range** (`origin/{base}...<branch>` — `{base}` is the base
+  branch `docs/_meta/engineering-loop.md` § This repository's rails (repository-owned) names, or the
+  remote's default when it names none; it is read from the remote's copy, because a local base branch can
+  sit behind it and pull another effort's commits into the range);
+- **one more range per further repository the run wrote**, with that repository's path — by its release
+  tags when the run released it mid-run, since its branch is merged by then;
 - **the brief** (`00-ignition-brief.md`) — its sections down to § Platform state, read as claims like the
   specs, and **never the coordinator's sections after it** (its beliefs, its close-out, its kick);
 - **every numbered spec path** — you read them as claims, not facts;
@@ -67,7 +70,10 @@ instrument, and a reader who takes it for a cold one over-trusts its independenc
 3. **The working docs** in `docs/working/` — the narrative: what was tried, what failed, what changed.
 4. **The tracker** — `project-status.md`, the coordinator's journal: rulings and their reasoning, recon
    corrections, incidents.
-5. **THEN the diff** — `git diff {base}...<pipeline-branch>`, plus `git log --oneline {base}..<pipeline-branch>`.
+5. **THEN the diff** — `git diff origin/{base}...<pipeline-branch>`, plus `git log --oneline
+   origin/{base}..<pipeline-branch>`; and the same pair for each further range your seed names, run inside
+   that repository. Read the two sides of a seam together: what one repository ships and what the other
+   consumes are one claim.
 
 **Read the artifacts before the code, and the code before you conclude.** Reading the diff first makes
 you review a patch; reading the claims first makes you review whether the pipeline did what it said.

package/skills/spec-seat/SKILL.md

@@ -278,24 +278,19 @@ Ask what the park is protecting:
 - **A park on your own legitimate in-worktree work** — **re-request it** (no self-imposed cap, no
   workaround, no silent giving-up) AND disclose ("blocked on X, re-requested N times"). A parked call is
   the platform's turn, not your failure; routing around it hides the defect the park is surfacing.
-- **A park on a boundary command** (push to the base branch, force-push, branch delete — or a command
-  whose *text* merely tripped the scanner) — **never re-request; reshape the command.**
-  **A search is data only in one shape:** a quoted literal pattern given to a read-only search tool (`rg`,
-  `grep`, `git grep`, `Select-String`, `findstr`), with no `$`, no backtick, no interpreter and no `xargs`
-  in the pipeline. Any other command carrying boundary words parks — search for the symbol, not the verb.
-  **THE SCANNER MATCHES TEXT, NOT PARSED VERBS, AND THIS IS THE MOST-PAID FENCE IN THE CEREMONY.** It
-  fires on read-only commands a careful seat runs to PROVE its work: an `echo` label reading
-  `=== remote tip ===` on a `git status`/`git log` block, or `git branch -r --contains <sha>` — a branch
-  **listing** — tripping the *"branch deletion is human-only"* backstop. **So the discipline belongs in
-  the prose you write around a command, not only in the command:** no git-verb vocabulary (push, remote,
-  force, reset, branch delete) in any `echo`, comment, `--description` or section label. For upstream
-  verification use `git log origin/<branch>..HEAD | wc -l` and `git status -sb`, which carry no colliding
-  noun.
+- **A park on a boundary command** (push to the base branch, force-push, branch delete — or a command the
+  gate read as one) — **never re-request; reshape the command.**
+  **THE GATE READS THE COMMAND THE SHELL WOULD RUN, NOT ITS WORDS.** What parks is the operation — a
+  publish, a remote change, a branch deletion, a merge — at any depth: wrapped, chained, or named inside
+  another program's words. An `echo` label naming a git verb, a branch listing and a quoted search pattern
+  are data to it. **They stop being data when something on the line could run them:** a shell or an
+  interpreter anywhere on the line, or a `$`, a backtick or an `xargs` in the pipeline. So keep a proof
+  command plain — one program, quoted literals — and give a search to a read-only search tool (`rg`,
+  `grep`, `git grep`, `Select-String`, `findstr`).
   **RESHAPE MEANS A DIFFERENT COMMAND, NEVER A DISGUISED ONE — NEVER ROUTE AROUND A REFUSAL.** Rewriting a
-  path with a glob or a quote so the scanner no longer sees the word it matched (a `?` in place of one
-  letter of a folder name) defeats every text-scanned rule at once, and the same disguise passes a real
-  boundary command. When the only way through is to hide the word, the park is a false one: disclose it,
-  with the verbatim command and park text, and ask.
+  path with a glob or a quote so a word is no longer seen (a `?` in place of one letter of a folder name)
+  is a disguise, and the same disguise passes a real boundary command. When the only way through is to
+  hide the word, the park is a false one: disclose it, with the verbatim command and park text, and ask.
 - **A POLICY WALL is none of the three.** If the refusal says `walled-by-policy`, **an approval cannot
   grant it** and re-requesting is walking through a known fail-open. The two routes are **reshape the work**
   (do it by a path the policy allows — often: hand the text to a seat whose scope covers it) or
@@ -325,9 +320,11 @@ Plain text, BEFORE any plan-approval presentation:
 
 ```
 PLAN TLDR ({your assignment}), recon done against HEAD {sha}, anchors {verified fresh / drift: …}:
-BELIEFS: HEAD {sha}; dirty files I see: {list, whose}; tool versions: {the harness, the runtimes};
-baseline suites: {cited from the brief's § Baselines, per lane: N (+known pre-existing reds); a lane it
-does not name, measured before you edit}.
+BELIEFS: HEAD {sha}; dirty files I see: {list, whose}; tool versions: {the harness, the runtimes, and the
+model and effort this session is running on}; baseline suites: {cited from the brief's § Baselines, per
+lane: N (+known pre-existing reds); a lane it does not name, measured before you edit}.
+{when your row names a further repository, one line each:}
+ALSO WRITING {repository}: commit {sha} on {branch}; dirty files there: {list, whose}.
 CONTROLS: for each probe or pin I will build — its positive control, and what would make it FAIL.
 {one line each: "probe X — control: {the case that must go red}; fails when: {…}"}
 {5-10 lines: what you will do, anchored to real files; the surfaces you will touch; departures flagged.}
@@ -343,9 +340,18 @@ coordinator with your question text and what the re-raise keys on (the two-headi
 **BELIEFS sha — ONE line.** The build-go HEAD check scans for `HEAD` + a 40-hex token **on the same line**
 (fenced or quoted is fine); a markdown break between them reads as a malformed sha and **refuses the
 flip** (fail-closed by design). Paste the verbatim `git rev-parse HEAD` output, never hand-transcribe, no
-wrapping. **Put the BELIEFS line near the top of BOTH `plan.md` and `tldr.md`**, and keep it current on
-every revision: a checker that takes the first `HEAD <sha>` it meets reads an old line before a new one, and
-quoted command output carrying another sha above it is read as your belief.
+wrapping. **Put the BELIEFS line near the top of BOTH `plan.md` and `tldr.md`. When your HEAD moves,
+restate it by appending a new `BELIEFS:` line, never by editing the old one:** the check reads the newest
+line that carries `BELIEFS`, and with none it takes the first `HEAD <sha>` it meets, so quoted command
+output carrying another sha is then read as your belief.
+
+**A further repository's commit goes on its own `ALSO WRITING` line, beneath the BELIEFS line and never
+beside the word `HEAD`:** the BELIEFS line carries one sha, this repository's, and your coordinator diffs
+the other line against that repository's branch.
+
+**The model and effort in that line are the ones you can read, never the brief's copied back.** The brief's
+`## Birth` names the pair every seat starts on, and a seat that finds itself on another says so here, before
+its plan. Write *not visible from here* for a part your session cannot see.
 
 **Cite symbols, not line numbers.** In anything that outlives a commit — a TLDR, a working doc, a handover
 — **name the symbol and use the line as a hint.** A line number is a comment, not an address; an anchor
@@ -424,15 +430,34 @@ doorbell with no follow-through**; if you receive one bare, retry anyway and say
   disqualifier is **anything else on the line**, and a leading `cd` — harmless on every OTHER git call you
   make — disqualifies a push (the FORM check reads the whole command string). Qualifying forms, exactly:
   first `git push -u origin <your-branch>`, later `git push origin <your-branch>` (`--set-upstream` also
-  qualifies). A push without a refspec parks by design.
+  qualifies). A push without a refspec parks by design. This is your push in THIS repository; a further
+  repository's push has its own form, below.
 - **EVERY GIT COMMAND GOES ALONE — no shell metacharacters.** The FORM check reads the whole command
   string, so chaining, redirects or substitution disqualify it: `git add … && git commit … && git push …`
-  parks where the same three commands, sent one at a time, flow unattended. Keep the word "push" out of
-  echo text — the deny layer matches text, not parsed verbs.
+  parks where the same three commands, sent one at a time, flow unattended.
 - Prefer native read/glob/grep tools for reads; a shell read flows with its row like any other
   non-boundary call. On a periscope 1.4.0 runner they reach anything outside your workspace except
   credential material; on an older runner Read is jailed to your workspace, so read a file outside it —
   the runner's installed package, say — with a shell command.
+- **WHEN YOUR ROW NAMES A FURTHER REPOSITORY, YOU WORK IN TWO TREES, AND EACH KEEPS ITS OWN RULES.** Most
+  rows name none, and nothing in this bullet applies to them.
+  - **Your home is this repository:** your spec, board, plan and working doc stay here, and nothing of
+    the pipeline's record is ever written in the other repository.
+  - **The other repository takes your code, in your own tree of it — never its owner's checkout.**
+    Hosted, your seed names the environment variable holding that tree's path: read it, never build the
+    path. Hand-cranked, your prompt names the path. Read the branch in the tree itself; it need not carry
+    this repository's branch name.
+  - **This section applies once per repository:** an explicit staging list and its `verify-staged`
+    receipt, run inside that tree; its own commit; and before its push, the whole of ITS gate — the suite
+    and checks its own contributing rules name, which this repository's lanes never run.
+  - **Its commit and pull-request text follow ITS rules:** no effort ids, no board or seat words. Where it
+    checks pull requests, open a DRAFT one at your first push and read its checks after every push.
+  - **Push from inside that tree — `cd "$TREE" && git push origin <branch>`, and nothing else on the
+    line,** with the variable your seed names in `$TREE`'s place (hand-cranked, the path your prompt
+    names). It is the one push that takes a leading `cd`. Keep the variable out of the push itself:
+    `git -C "$TREE" push` cannot be read, and waits for a person. Your push may wait for one anyway: wait,
+    never reshape it, and report a refusal.
+  - **You never merge, tag or publish there.** A release is a person's act, at the pipeline's `step`.
 - **Codegen only through the command `patterns/codegen.md` § Running codegen names** (when the repo has
   one) — never hand-write a generated folder.
 - **Never improvise a qualifying path in.** If a push parks and the remedy you can think of is touching a
@@ -462,7 +487,9 @@ FINAL TLDR — {your assignment}. Built on HEAD {sha}; {hand-cranked: committed
 (f) EXPLICIT STAGING LIST — the exact list `verify-staged` was (hand-cranked) or will be (hosted)
     run over; a path not on this list is a path nobody will notice missing — + the STAGING
     VERIFIED receipt, or hosted "commit HELD awaiting the commit call" + which dirty files are NOT
-    mine. SESSION ID + NAME.
+    mine. A seat that wrote a further repository gives a list and a receipt PER REPOSITORY, each
+    under its repository's name, and in (b) each repository's summaries under its own name.
+    SESSION ID + NAME.
 ```
 
 ## Close-out — the order is law