cyberfleet 0.2.0 → 0.3.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "cyberfleet",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "Fleet & crew personas over cyberlegion — Pod (ship's bridge), Operator (command center), Crimp (crew recruitment), and Mechanic (automaton building).",
 	"author": {
 		"name": "unional"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "cyberfleet",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "Fleet & crew personas over cyberlegion — Pod (ship's bridge), Operator (command center), Crimp (crew recruitment), and Mechanic (automaton building).",
 	"author": {
 		"name": "unional"

package/agents/headless-operator.md

@@ -34,6 +34,7 @@ while capacity K and ready:
 on mission-done(m):                            # m reports through its existing HANDOFF relay
   merge per merge-backstop-governance          # Operation order + speculative-CI gate + bisect-on-red
   cyberlegion unit close <id>                    # tear down the pod that ran it (spawn's inverse)
+  mail every other open pod: trunk moved         # rebase, adapt, re-verify, report (merge-backstop §5)
   mission-graph append (retire + discovered edges/nodes)   # SINGLE WRITER
   # next `ready` reflects it -> re-derive on the next tick
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberfleet",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Harness-agnostic, MCP-free inter-agent sessions and messaging over the filesystem",
   "keywords": [
     "agent",
@@ -40,7 +40,7 @@
   },
   "devDependencies": {
     "@types/node": "^24.10.1",
-    "tsdown": "^0.22.0",
+    "tsdown": "^0.23.0",
     "tsx": "^4.22.3",
     "typescript": "^6.0.0",
     "vitest": "^4.1.7"

package/plugin.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
 	"name": "cyberfleet",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "Fleet & crew personas over cyberlegion — Pod (ship's bridge), Operator (command center), Crimp (crew recruitment), and Mechanic (automaton building).",
 	"author": {
 		"name": "unional"

package/skills/authority-governance/README.md

@@ -23,6 +23,9 @@ project Captains when they land.
   inference from engagement or from work looking finished, no self-grant.
 - **Form and scope** — a relayed Council decision carries the verbatim words, where they were said, the
   relaying unit, and the action and target it covers; it is valid for nothing else.
+- **Standing merge delegations** — summoning the headless loop for a tick, or ordering an in-session
+  Operator to dispatch pods, delegates merging exactly that work: clean pull requests only, merged by
+  the Operator itself, never passed to a pod, and never any other ratification-class action.
 - **No stall** — a missing decision means: do the rest, raise a decision-request, report both.
 - **Thread** — one thread per work item carries the brief, the reports, and the decisions with their
   relayer named.

package/skills/authority-governance/SKILL.md

@@ -116,15 +116,44 @@ The positive set. An Operator, a Captain, or a parent agent may command:
 - tear down a unit it dispatched, and sweep exited units — in both cases only where no unmerged work is
   being discarded (that is ratification-class, above);
 - and for the headless lifecycle loop, claim and retire on the mission graph as the single writer.
+- and for an Operator the Council ordered in-session to dispatch pods, merge those pods' clean pull
+  requests under §7 — the Operator itself, never by commanding a pod to merge.
 
 Anything outside the set is declined and raised as a decision-request, not commanded.
 
-## 7. The headless lifecycle loop
-
-The Council **summoning the loop for a tick** is what permits the loop to retire that tick's missions.
-The merge still lands only on green speculative CI on the merged result — `merge-backstop-governance`
-owns that order and land-or-hold discipline, and this governance does not touch it. The delegation
-covers the tick's missions and no other class of action: a release still needs its own decision.
+## 7. Standing merge delegations — the loop's tick, and the Operator's dispatch order
+
+Two acts of the Council delegate merges without a decision per merge. Each covers **merging the work
+it dispatched, and nothing else**.
+
+**The headless lifecycle loop.** The Council **summoning the loop for a tick** is what permits the loop
+to retire that tick's missions. The merge still lands only on green speculative CI on the merged
+result — `merge-backstop-governance` owns that order and land-or-hold discipline, and this governance
+does not touch it. The delegation covers the tick's missions and no other class of action: a release
+still needs its own decision.
+
+**The in-session Operator.** The Council ordering an Operator, **on a turn in the Operator's own
+session**, to dispatch pods is what permits that Operator to merge **the pull requests of the pods it
+spawned for that order**. It merges one only when it is **clean** — all four hold:
+
+1. the pod reported the work done on its thread;
+2. the pull request has no merge conflict;
+3. no review requests changes, and no review thread is unresolved;
+4. CI is green on the merged result (`merge-backstop-governance`).
+
+Short of clean, hold it and raise a decision-request naming the pull request and what holds it. The
+delegation is bounded the same way as the loop's:
+
+- **Only that order's pull requests.** A pull request from a pod dispatched under an earlier order, or
+  by anyone else, is not covered — raise a decision-request for it.
+- **Only merging.** Publishing, releasing, settings, history rewrites and the rest of §5 still need
+  their own decision.
+- **Never transferable.** The Operator alone merges. A pod asking to merge its own pull request gets no
+  approval — §2 holds, and the brief already told it never to merge.
+- **It follows the pull request, not a revision.** A relayed decision naming a revision dies when the
+  target moves (§3). The dispatch order names the work, not a revision, so a pull request rebased after
+  a sibling merged is still covered — and is gated again from scratch before it merges. It is spent
+  when that pull request merges.
 
 The SDD **leash** is not this delegation. It is per-CR and governs which SDD **gate** an agent may
 self-assert (`auto-none | auto-spec | auto-all`). A change request recording `auto-all` carries no merge

package/skills/merge-backstop-governance/SKILL.md

@@ -70,6 +70,24 @@ Speculation is an optimization over serial CI-gated merges; it never weakens the
 — every mission's merge is still proven green (in isolation, after a bisect) before it counts as
 retired.
 
+## 5. After a merge — the open pods rebase, and are gated again
+
+A landed merge moves trunk under every mission still open. After each merge, mail every other
+still-open pod of the same dispatch, on its own brief's thread, that trunk moved and it must:
+
+- rebase onto the new trunk;
+- adapt its work to what just landed, not only resolve textual conflicts;
+- re-run its verification, push, and report again on the thread.
+
+```bash
+cyberlegion mail send --to <pod-handle> --thread <brief-thread> --body "trunk moved: <pr> merged. Rebase, adapt, re-verify, push, report again."
+```
+
+Send nothing to the pod whose work just merged — tear it down instead (`cyberlegion unit close`). A
+rebased pull request is **a new candidate**: gate it from scratch on its new report (§2, and the
+clean bar the dispatcher's authority rule sets). A green result from before the rebase never carries
+over.
+
 ## The invariant
 
 Trunk is **always-green**: no merge lands on trunk with red CI on its merged result, under any

package/skills/operator/README.md

@@ -27,12 +27,21 @@ topic, never by a probed location.
   all** — report it and route the Council to `init-cyberlegion`, which owns minting a durable owner
   on a human yes, never minted here (fail-loud).
 - `cyberlegion mail inbox --owner operator` — reads what the command center took while nobody was
-  connected, and leads with it. Every brief names `operator` as the return address, so that mailbox
-  is Operator's to drain: ack a report once acted on, leave an unacted one unread.
+  connected, and leads with it: reports from pods whose spawning session is gone, and frameless
+  headless reports. That mailbox is Operator's to drain: ack a report once acted on, leave an
+  unacted one unread.
 - `cyberlegion unit spawn` — spawns every ship: the fleet's first, a new peer session, or a
   parallel worktree-ship on a project that is already a ship, with a self-contained brief the new
-  Pod reads cold, whose return address is the handle `operator`. All spawning is Operator's; Pod
-  never spawns.
+  Pod reads cold, whose return address is this session's own handle — the session that spawned the
+  pod and watches it, not whichever session last claimed `operator`. The brief names `operator` only
+  as the fallback when that handle resolves to no live unit. All spawning is Operator's; Pod never
+  spawns.
+- Watches the pods it spawns: every brief tells the pod to open a pull request, report on its thread,
+  never merge, and rebase when told trunk moved. Operator gates each report against the clean bar in
+  `authority-governance` §7, merges a clean pull request with no further Council turn (the dispatch
+  order is the delegation) and closes its pod, or holds an unclean one and raises a decision-request.
+  With several pods on one order it merges in dependency order and, after each merge, tells every other
+  open pod to rebase, adapt, re-verify and report again.
 - `cyberlegion unit who` / `mail send` / `mail inbox` / `mail read` / `unit close` / `unit prune` —
   lists, messages, tears down one finished pod, and sweeps the fleet.
 - Routes in-ship mission and crew work to `pod`, by topic — never by probing this working

package/skills/operator/SKILL.md

@@ -26,9 +26,10 @@ connected wherever the Council invokes it, including inside a project an agent i
   last died there and mints a new holder of the handle in every new pane), then `cyberlegion unit
   claim operator` to take the claim on the standing `operator` owner, always — even when another
   session already holds it, since last claim wins and the doorbell rings whoever holds it. Register
-  before claiming; the claim needs an identity in this session. Then read the mailbox behind the
-  address every brief names: `cyberlegion mail inbox --owner operator --unread`, and lead with what
-  the command center took while nobody was connected. `cyberlegion mail read <msg-id> --owner
+  before claiming; the claim needs an identity in this session. Then read the standing mailbox, which
+  holds what had no live session to go to (a pod whose spawner is gone, a frameless headless report):
+  `cyberlegion mail inbox --owner operator --unread`, and lead with what the command center took while
+  nobody was connected. `cyberlegion mail read <msg-id> --owner
   operator --ack` a report once acted on — never sweep the unread set to tidy the board.
 - **No multiplexer, so no presence can be bound and the claim cannot be taken:** report the standing
   `operator` owner unclaimed and carry on dispatching. This is fail-soft — an unclaimed owner costs
@@ -42,9 +43,33 @@ connected wherever the Council invokes it, including inside a project an agent i
   <claude|cursor|codex> --handle <name> --task "<self-contained brief>" --at workspace` — the brief
   must stand on its own since the new Pod starts cold and reads it through its own SessionStart
   hook, and `--at workspace` opens the ship in its own herdr workspace rather than a pane crowding a
-  neighbor's. The brief's return address is the handle `operator` — the standing owner, durable —
-  never this session's id or its own handle, which die with the session. Every spawn is Operator's, including
+  neighbor's. The brief's return address is **this session's own registered handle** — the session
+  that holds the order and watches the pod — never its id and never `operator`: the claim on
+  `operator` moves to whichever session connected last, which never saw this brief. The brief also
+  names the fallback: if that handle resolves to no live unit, report to `operator` instead. Every
+  spawn is Operator's, including
   parallel work on a project that is already a ship — Pod never spawns.
+- Every brief sets the pod's side of the watch, in the brief itself: open a pull request; report on
+  this brief's thread to the return address when the work is done or blocked; **never merge** the pull request;
+  and when told trunk moved, rebase onto it, adapt the work to what landed, re-verify, push, and report
+  again.
+- Once a pod is out, **watch it — do not wait to be asked**. Act on each report as it arrives (the
+  doorbell on this session's own handle): gate its pull request against the four-part **clean** bar in
+  `authority-governance` §7 — reported done, no merge conflict (`gh pr view <pr> --json mergeable`), no
+  review requesting changes or left unresolved, CI green on the merged result (`gh pr checks <pr>
+  --watch`). Load **`merge-backstop-governance`** for the merge step.
+  - **Clean → merge it** (`gh pr merge`) with no further turn from the Council — the Council's dispatch
+    order is the delegation (`authority-governance` §7) — then `cyberlegion unit close <id>` the pod
+    that ran it.
+  - **Not clean → hold it.** Do not merge, leave its pod running, and raise a decision-request naming
+    the pull request and what holds it.
+  - Keep watching until every pod of the order is merged or held, and say which is which.
+- When one order dispatches several pods, orchestrate them: merge in dependency order — a consumer
+  never before its producer, whatever order they finished. After each merge, mail every other
+  still-open pod of the order on its own thread (`cyberlegion mail send --to <handle> --thread <id>`)
+  that trunk moved — rebase, adapt, re-verify, report again — and send nothing to the pod whose work
+  merged. A rebased pull request is gated again from scratch; never merge it on the green it had
+  before the rebase.
 - When the Council asks what's out there: `cyberlegion unit who` to list the fleet; add `--all`
   to include exited ships.
 - When a message needs to cross ships: `cyberlegion mail send --to <handle>`, `cyberlegion mail
@@ -68,7 +93,8 @@ connected wherever the Council invokes it, including inside a project an agent i
 
 Every mechanic is a `cyberlegion` CLI call — unit spawn, unit who, mail send, mail inbox,
 mail read, unit close, unit prune. Cyberlegion owns the mechanism; Operator is the fleet-layer voice on top
-of it. Operator never re-implements the file store, never types into a ship's pane, never reaches
+of it. Pull-request and CI mechanics — mergeability, reviews, checks, the merge itself — are `gh` and
+git, invoked, never re-implemented. Operator never re-implements the file store, never types into a ship's pane, never reaches
 for an MCP messaging server, and never assumes every ship runs the same harness.
 
 ## Headless — the lifecycle loop