@openrig/cli 0.4.2 → 0.4.4

package/daemon/specs/agents/development/implementer/agent.yaml

@@ -11,7 +11,7 @@ imports:
 profiles:
   default:
     uses:
-      skills: [using-superpowers, openrig-user, development-team, test-driven-development, systematic-debugging, verification-before-completion, writing-plans, executing-plans]
+      skills: [using-superpowers, openrig-user, mission-slice-sop, development-team, test-driven-development, systematic-debugging, verification-before-completion, writing-plans, executing-plans]
       guidance: []
       subagents: []
       runtime_resources: [shared:claude-default-settings, shared:claude-default-mcp, shared:codex-default-config]

package/daemon/specs/agents/development/implementer/guidance/role.md

@@ -7,6 +7,7 @@ You are the implementation side of a dev pair. Your job is to write code, not to
 Load these packaged skills now before editing:
 - `using-superpowers`
 - `openrig-user`
+- `mission-slice-sop`
 - `development-team`
 - `test-driven-development`
 - `systematic-debugging`

package/daemon/specs/agents/development/qa/agent.yaml

@@ -11,7 +11,7 @@ imports:
 profiles:
   default:
     uses:
-      skills: [using-superpowers, openrig-user, development-team, systematic-debugging, verification-before-completion, agent-browser, dogfood, writing-plans, executing-plans]
+      skills: [using-superpowers, openrig-user, mission-slice-sop, development-team, systematic-debugging, verification-before-completion, agent-browser, dogfood, writing-plans, executing-plans]
       guidance: []
       subagents: []
       runtime_resources: [shared:claude-default-settings, shared:claude-default-mcp, shared:codex-default-config]

package/daemon/specs/agents/development/qa/guidance/role.md

@@ -7,6 +7,7 @@ You are the quality assurance side of a dev pair. You gate every edit the implem
 Load these packaged skills now before reviewing work or dogfooding:
 - `using-superpowers`
 - `openrig-user`
+- `mission-slice-sop`
 - `development-team`
 - `systematic-debugging`
 - `agent-browser`

package/daemon/specs/agents/orchestration/orchestrator/agent.yaml

@@ -11,7 +11,7 @@ imports:
 profiles:
   default:
     uses:
-      skills: [using-superpowers, openrig-user, orchestration-team, systematic-debugging, verification-before-completion, writing-plans, executing-plans, brainstorming]
+      skills: [using-superpowers, openrig-user, mission-slice-sop, orchestration-team, systematic-debugging, verification-before-completion, writing-plans, executing-plans, brainstorming]
       guidance: []
       subagents: []
       runtime_resources: [shared:claude-default-settings, shared:claude-default-mcp, shared:codex-default-config]

package/daemon/specs/agents/orchestration/orchestrator/guidance/role.md

@@ -7,6 +7,7 @@ You are the orchestrator. You coordinate the work of other agents in this rig, m
 Load these packaged skills now before doing substantive work:
 - `using-superpowers`
 - `openrig-user`
+- `mission-slice-sop`
 - `orchestration-team`
 - `systematic-debugging`
 - `brainstorming`

package/daemon/specs/agents/product-management/pm/agent.yaml

@@ -16,6 +16,7 @@ profiles:
     uses:
       skills:
         - openrig-user
+        - mission-slice-sop
         - office-hours
         - context-builder
         - requirements-writer

package/daemon/specs/agents/product-management/pm/guidance/role.md

@@ -3,6 +3,19 @@
 ## Role
 Senior Product Manager. Own the "what" and "why" — never architecture, estimates, or implementation details.
 
+## Skills Loaded
+
+Load these packaged skills now before shaping product work:
+- `openrig-user`
+- `mission-slice-sop`
+- `office-hours`
+- `context-builder`
+- `requirements-writer`
+- `ui-mockup`
+- `plan-review`
+- `exec-summary`
+- `backlog-capture`
+
 ## 8-Step Feature Flow
 
 1. **Capture** — run `backlog-capture` and record the idea in `idea_backlog.md`.

package/daemon/specs/agents/review/independent-reviewer/agent.yaml

@@ -11,7 +11,7 @@ imports:
 profiles:
   default:
     uses:
-      skills: [using-superpowers, openrig-user, review-team, systematic-debugging, verification-before-completion, writing-plans, brainstorming]
+      skills: [using-superpowers, openrig-user, mission-slice-sop, review-team, systematic-debugging, verification-before-completion, writing-plans, brainstorming]
       guidance: []
       subagents: []
       runtime_resources: [shared:claude-default-settings, shared:claude-default-mcp, shared:codex-default-config]

package/daemon/specs/agents/review/independent-reviewer/guidance/role.md

@@ -7,6 +7,7 @@ You are an independent code reviewer. You analyze code on your own merits withou
 Load these packaged skills now before reviewing:
 - `using-superpowers`
 - `openrig-user`
+- `mission-slice-sop`
 - `review-team`
 - `systematic-debugging`
 - `brainstorming`

package/daemon/specs/agents/shared/agent.yaml

@@ -26,6 +26,8 @@ resources:
       path: skills/core/openrig-architect
     - id: rig-lifecycle
       path: skills/core/rig-lifecycle
+    - id: mission-slice-sop
+      path: skills/core/mission-slice-sop
     - id: systematic-debugging
       path: skills/process/systematic-debugging
     - id: test-driven-development

package/daemon/specs/agents/shared/skills/core/mission-slice-sop/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: mission-slice-sop
+description: Use when working a mission or slice — the full SDLC flow (intent → mini-requirements + proof contract → mockups → plan-lock → build → QA visual compare → `rig proof` drops → proof-lock) plus how to track, prove, hand off, and carry state across agents and compaction via the canonical files (PROGRESS.md / PROOF.md / MISSION_NOTES.md / MISSION_BRIEF.md / README.md / IMPLEMENTATION-PRD.md). Covers the convention sections the Living Notes UI projects, the two locks, the three role contracts, per-file WHO/WHEN/HOW rules, the four-legs lifecycle, hot-potato queue handoffs, the moment-of-truth checklist, the deterministic `rig scope audit` backstop, and the ghost-text capture gotcha.
+metadata:
+  openrig:
+    stage: shipped
+    last_verified: "2026-07-06"
+    distribution_scope: product-bound
+    source_evidence: |
+      Authored + embedded in release-0.4.3 slice 32 (mission-slice-sop);
+      moved into the canonical product skill source and updated in
+      release-0.4.4 slice 23 (operationalize the SDLC control plane) to
+      teach the full SDLC flow the Living Notes UI projects: the convention
+      sections, the proof-contract pairing, the two staged-approval locks,
+      C1 proof drops, and the three role contracts. Conventions SSOT:
+      docs/reference/sdlc-conventions.md (shipped with the CLI package).
+      The deterministic backstop is the `rig scope audit` classifier.
+    sibling_skills:
+      - queue-handoff
+      - seat-continuity-and-handover
+      - claude-compaction-restore
+---
+
+# Mission/Slice SOP — how you work a mission & slice
+
+Use this skill to actually **do** mission/slice work the way OpenRig expects: author the convention sections, track on the canonical files, prove on them, hand off through them, and survive compaction on them. **Do the work described here; do not merely explain the protocol.** The deterministic backstop is `rig scope audit` — the audit classifier is the source of truth for adherence. The conventions themselves live in ONE place: **`docs/reference/sdlc-conventions.md`** (shipped with the CLI package) — this skill teaches the flow; the SSOT defines the formats.
+
+## The SDLC flow (intent → proof)
+
+```
+intent → mini-requirements + proof contract → (UI slices: mockups)
+      → plan-lock (rig scope slice approve --scope spec)
+      → build the LOCKED set
+      → QA: mockup ↔ delivered VISUAL compare
+      → proof drops (rig proof add <slice> …)
+      → proof-lock (rig scope slice approve --scope delivery)
+```
+
+1. **Record intent** verbatim in the slice's `## Intent` section (`rig scope slice create` scaffolds it — every template kind).
+2. **Author the mini-requirements + proof contract**: `## Mini-requirements` is the concise one-glance tier (approval starts there); `## Proof contract` is a checkbox list of promised deliverables, each written as an observable outcome. UI deliverables name their planned mockup. The IMPLEMENTATION-PRD opens with the mini-requirements; everything between intent and proof is **elastic** — for a small slice the mini-requirements may BE the whole PRD.
+3. **Plan-lock**: `rig scope slice approve <slice> --scope spec` — "the PRD matches the intent; THIS artifact set is what gets built." One daemon-side write: frontmatter stamp + append-only audit row.
+4. **Build the locked set** — look at the mockups, not just the spec text.
+5. **QA visual compare**: for each deliverable, load the planned mockup, produce the real artifact in a test/demo environment, visually compare, and record the verdict.
+6. **Drop proof**: `rig proof add <slice> --artifact-type qa --verdict PASS --candidate-sha <tip> --money-evidence "…" --evidences "1,3" --media "walk.webm,panel.png" --self-check "…"` — the C1 header's closed sets validate at drop time; `--evidences` joins the drop to its proof-contract items and `--media` names the curated proof/-relative media the drop stands behind (that pairing + media set is what the UI's DELIVERED section renders).
+7. **Proof-lock**: `rig scope slice approve <slice> --scope delivery` — the terminal sign-off. Approval is freeze/sign-off, **never** proven-green: proven-green requires the recorded C1 verdicts.
+
+## The three role contracts
+
+- **Planning agent:** authors intent + mini-requirements + the proof contract; produces mockups for UI deliverables and attaches them to the locked set (a UI slice with no mockup is an incomplete plan; non-UI slices have none — not a gate); locks the plan.
+- **Build agent:** builds against the LOCKED set only; looks at the mockups.
+- **QA agent (owns the compare):** visually compares planned vs delivered per deliverable, records verdict + note via proof drops, and **curates** the canonical proof set (bounded, mapped to deliverables; the fix-loop pile stays in `proof/`, one drill-in down). On mismatch: fix-and-re-review or kick back with the reason — never escalate a raw mismatch to the human.
+
+## The canonical files (the operating surface)
+
+> The canonical files below are the **operating surface of the work** — you track on them, prove on them, hand off through them, and survive compaction on them. They are NOT side-artifacts to "maintain"; keeping them current *is* the work.
+
+- **README.md** (mission + slice) — the overview, OPENING with the convention sections (`## Intent` / `## Mini-requirements` / `## Proof contract`). The **mission README carries this SOP at its bottom.**
+- **IMPLEMENTATION-PRD.md** — the full PRD; opens with the mini-requirements; the `## Proof contract` here is what the UI's DELIVERED pairing joins proof against.
+- **PROGRESS.md** — the live delivery state. One line per outcome; links down for detail.
+- **MISSION_NOTES.md** — the accruing handoff + tribal-knowledge doc. Blank-slate onboarding + **compaction-restore** read it. `§1` top-of-mind + per-seat `§A–§X`.
+- **MISSION_BRIEF.md** — the steering doc (the UI "Steering" tab). The 7-section schema.
+- **PROOF.md** (+ `proof/`) — acceptance evidence. **A slice is not done until every proof-contract item has evidence.**
+
+## Per-file rules — WHO / WHEN / HOW
+
+### PROGRESS.md
+- **WHO:** the orchestrator owns `§1` (current state); every agent logs its own outcomes.
+- **WHEN:** after every slice-done **AND every commit**; on any material state change.
+- **HOW:** one line per outcome (checkbox), link down for detail (workstream-continuity format); keep frontmatter `stage`/`verified` honest.
+
+### PROOF.md + proof/
+- **WHO:** the impl/QA pair that worked the slice.
+- **WHEN:** a slice is **NOT "done"** until every proof-contract item has evidence.
+- **HOW:** proof maps **1:1 to the proof contract's deliverables** — put media under `proof/`, then ATTACH it with `rig proof add <slice> … --evidences <item> --media <files>` (the drop writes the C1 header the DELIVERED pairing joins on) + a line in PROOF.md stating what it proves. **Hand-placing files in `proof/` without a drop is the anti-pattern** — the deliverable stays unpaired and `unverified`. No proof → not done.
+
+### MISSION_NOTES.md
+- **WHO:** any agent updates `§1` (top-of-mind); each seat owns + appends to its own `§A–§X` section.
+- **WHEN:** on any material change; a compacting agent **files its state here BEFORE compaction and reads it on restore.**
+- **HOW:** accruing tribal knowledge — `§1` ≤ 5–15 lines (gates, open decisions, surprises); per-seat continuation entries (latest = truth; other seats read-only). Pointer-first; don't duplicate.
+
+### MISSION_BRIEF.md
+- **WHO:** product/design (steering owner).
+- **WHEN:** when steering changes.
+- **HOW:** the 7-section steering schema (the UI "Steering" tab reads it).
+
+### README.md
+- **WHO:** the author at creation; refreshed on rescope.
+- **WHEN:** at mission/slice creation + when scope/theme changes.
+- **HOW:** overview + honest frontmatter (`id`/`stage`/`verified`) + the convention sections up top; the mission README carries this SOP at its bottom.
+
+## The lifecycle (4 legs)
+
+**SCAFFOLD** (`rig scope` creates the files from templates — every slice kind emits the convention sections + `proof/` + the IMPLEMENTATION-PRD skeleton) → **POPULATE** (agents fill them as work happens, per the rules above) → **PROJECT** (the Living Notes UI reads them into INTENT → PLAN → DELIVERED) → **VERIFY** (`rig scope audit` checks adherence). "Loose freeform write + deterministic verify."
+
+## Hot-potato (handoffs)
+
+End every turn by passing the ball — a `rig queue` handoff to the next agent (close the qitem with a `closure_reason`). The **durable ball-pass is the queue close, not a chat message.** Never go idle without a handoff.
+
+## Verify (deterministic backstop)
+
+Run `rig scope audit` at slice-close. It flags: committed-without-touching-PROGRESS; slice-marked-done-without-PROOF; active-mission-without-MISSION_NOTES; MISSION_BRIEF off-schema; proof artifacts violating the C1 header; missing IMPLEMENTATION-PRD on a building slice; missing convention sections (`## Intent`, a well-formed `## Proof contract`, the UI-slice mockup ref). Every convention check is **advisory / fail-open** — it records and advises, never blocks a write. **Fix the flag, don't suppress it.**
+
+## Reading terminal captures — KNOWN GOTCHA: ghost-text autocomplete is NOT real
+
+When you `rig capture` a pane, **greyed / ghost autocomplete suggestions are NOT real content** — they are autocomplete *previews* (shell autosuggestion, the input-box ghost-text completion), not typed, staged, or committed input. **This is known, expected, and has been faking agents out a lot** — reading a ghost suggestion in a peer's input box as "staged text they're about to send," or as a real prompt, and then reasoning/acting on a string that was never actually there.
+
+**Rule:** ignore ghost/autosuggest text entirely. Only *committed/rendered* pane output is real. If a `❯` input line shows text, treat it as an autocomplete artifact unless you have independent evidence it was actually entered. Do not build decisions (or worry about "colliding with staged text") on ghost text. When it matters, verify at source (git, the queue, the actual event) — never off a capture's ghost line.
+
+## Moment-of-truth checklist
+
+- **Starting a slice?** → intent recorded verbatim? mini-requirements + proof contract authored? mockups attached (UI slices)? plan locked (`--scope spec`)?
+- **Finishing a slice?** → every proof-contract item has curated evidence via `rig proof add … --evidences --media` (C1 drops — never only hand-placed files)? PROGRESS updated? MISSION_NOTES `§1` refreshed? proof locked (`--scope delivery`)? Handed off via queue?
+- **Committing?** → PROGRESS updated?
+- **Compacting?** → filed your state in MISSION_NOTES?
+- **Starting on a mission?** → read the mission README (incl. this SOP) + MISSION_NOTES + `docs/reference/sdlc-conventions.md`?

package/daemon/specs/agents/shared/skills/core/openrig-operator/SKILL.md

@@ -14,7 +14,7 @@ Use it when the problem may be the daemon, the shell/runtime surface, or stale h
 
 Use this skill when you see:
 - `rig whoami --json` returning partial identity
-- `rig ps --nodes --json` failing while some other `rig` commands still work
+- `rig ps --nodes -A --json` failing while some other `rig` commands still work
 - `Sent to ...` plus `Verified: no`
 - repeated unified-exec-process warnings
 - suspicion that stale helper processes are accumulating
@@ -28,13 +28,13 @@ Start with the minimum truthful operator read:
 ```bash
 rig whoami --json
 rig daemon status
-rig ps --nodes --json
+rig ps --nodes -A --json
 ```
 
 Interpret them together, not in isolation:
 - partial `whoami` can mean identity is inferable while daemon-backed surfaces are degraded
 - `daemon status` tells you whether the host daemon is up, not whether every seat can reach it cleanly
-- `ps --nodes --json` is the best machine-readable topology check when it works
+- `ps --nodes -A --json` is the best machine-readable fleet topology check when it works (v0.4.4: `--nodes` needs an explicit scope outside a managed session — `-A` for fleet, `--rig <name>` for one rig; the bare `rig ps` map is the cheap first glance)
 
 ## Verification Drift Vs Send Failure
 
@@ -104,7 +104,7 @@ If the warning or failure remains after stale-wrapper cleanup, re-check:
 
 ```bash
 rig daemon status
-rig ps --nodes --json
+rig ps --nodes -A --json
 ```
 
 If those remain healthy, the residual issue may still be in the host/tool/session layer rather than in OpenRig topology state.

package/daemon/specs/agents/shared/skills/core/openrig-user/SKILL.md

@@ -435,27 +435,47 @@ honestly and the UI exposes a one-click open-missing affordance.
 
 v0.4.0 flips the five most frequently invoked read-commands from firehose-by-default to compact-by-default, and `rig queue list` adopts the docker / kubectl read-command grammar. **All defaults preserve breadth and capability — the firehose is one explicit flag away.**
 
-### `rig ps` — current-rig default + compact-by-default + `-A`/`--all-rigs` + `--full`
+### `rig ps` — consolidated all-rigs default + the disclosure ladder (v0.4.4)
 
 ```bash
-rig ps                      # CURRENT-RIG, all-states, compact rig summaries (default)
-rig ps --json               # compact JSON array (TL;DR per node: session, rig, activity, assigned/pending, resumeTokenPresent boolean)
-rig ps -A                   # all-rigs (fleet breadth; was the v0.3.4 default)
-rig ps --rig <name>         # explicit-rig (overrides current-rig default)
-rig ps --nodes              # compact node inventory (current rig)
-rig ps --nodes -A           # cross-rig node inventory (was v0.3.4 default)
-rig ps --nodes --full       # complete record (the v0.3.4 per-node default shape; resumeToken VALUE retained here for downstream consumers)
+rig ps                      # ALL ACTIVE RIGS, one compact row each + rollup line + count line + ladder footer (default)
+rig ps --json               # bare array of ALL non-archived rigs (incl. stopped; existing keys + additive attentionCount)
+rig ps --rig <name>         # one rig's detail
+rig ps --nodes              # compact node inventory (current rig — session default, LOCAL only)
+rig ps --nodes --rig <name> # compact node inventory, named rig
+rig ps --nodes -A           # fleet node inventory, projected rows
+rig ps --nodes -A --full    # complete per-node records (the ONLY full fan-out; resumeToken VALUE retained here for downstream consumers)
 rig ps --nodes --session <sess>  # narrow to one canonical session
+rig ps --include-archived   # archived history as rows (otherwise ONE count line)
 rig ps --active             # opt-in active-state filter (does NOT change the all-states default — ps surfaces topology/readiness, where stopped/recoverable/attention IS the actionable signal)
 ```
 
-**v0.4.0 breadth + projection changes**:
-- **Slice 34**: default breadth is CURRENT-RIG (derived from `OPENRIG_SESSION_NAME`'s `@<rig>` suffix), not all-rigs. `-A` / `--all-rigs` widens to fleet. Matches the `rig queue list -A` pattern.
-- **Slice 25 + 26**: per-node TL;DR projection (compact) is the default; `--full` returns the raw byte-equivalent passthrough. Daemon-side `recoveryGuidance` relocated to a guidance-by-reference map (no longer duplicated per-node) — even `--full` benefits.
-- **All-states stays default** (different from `rig queue list` which defaults to active-only) — for `ps`, non-running states ARE often the actionable signal.
-- **Resume-token security (slice 34)**: `--full` JSON emits `resumeTokenPresent` (boolean) — the actual `resumeToken` value also remains in `--full` for downstream consumers that legitimately need it, but the compact default never carries it (an orch glance never accidentally leaks token material).
+**v0.4.4 consolidated default + disclosure ladder (OPR.0.4.4.21)**:
+- **The default is the fleet MAP**: every active rig as one O(rigs) compact row, with the host rollup ("N rigs · M seats · K need attention"), the archived/stopped count line, and the drill-ladder footer. The v0.4.0 current-rig default is RETIRED — it hid running rigs from the operator's field of view.
+- **`-A` has exactly ONE meaning**: the `--nodes` fleet widener. Bare `rig ps -A` errors (all-rigs IS the default; archived history stays behind `--include-archived`).
+- **The session-rig default applies ONLY to `--nodes`, and only locally.** Implicit scope defaults don't cross host boundaries: `rig ps --host <id> --nodes` requires an explicit `--rig` or `-A`; multi-host fan-out is rollup-only by default; the full explicit ladder (`--all-hosts --nodes -A`, `--full` for complete records) fans out per-node with hostId-stamped projected rows.
+- **STATED JSON contract**: default `--json` = bare array of ALL non-archived rigs INCLUDING stopped ones (scope-not-shape: existing keys preserved, additive `attentionCount`); only the human table folds stopped rigs into the count line.
+- **Resume-token security unchanged**: compact output never carries token material; `--full` retains it for consumers that legitimately need it.
 
-**STOP using `rig ps --nodes --json` as a fleet-wide casual status check assuming the v0.3.4 shape.** The v0.4.0 default is CURRENT-RIG + compact; explicit `-A --full` is the fleet firehose. The ~77,000-token status-glance incident is closed twice over (compact + scope).
+**The casual status glance is just `rig ps`.** The old fleet firehose is the explicit last rung: `rig ps --nodes -A --full`. The ~77,000-token incident class stays closed (compact + O(rigs) default + explicit ladder).
+
+### `rig host` — the multi-host registry verbs (v0.4.4)
+
+```bash
+rig host add --id <id> --transport ssh --target <tailnet-alias> --user openrig
+rig host add --id <id> --transport http --url http://100.x.y.z:7433 --bearer-env MY_TOKEN
+rig host list                       # pointers only — never secret values
+rig host doctor <id>                # stepwise: transport -> rig binary -> daemon -> identity
+rig host doctor <id> --posture product-factory-vps [--public-addr <ip>]
+```
+
+Exactly three verbs (capped); the VPS factory bootstrap is script + runbook
+(`docs/reference/product-factory-vps-runbook.md`). **Transport posture is
+DECIDED and documented** (cli-reference §Cross-host execution): ssh = pane ops
+(`send`/`capture`), http = daemon REST (`up`/`down`/`launch`), `ps`/`whoami`
+follow the DECLARED transport; fan-out is http-only; no cross-transport
+fallback; no http parity for send/capture in 0.4.4. Posture/doctor UNKNOWN is
+never pass — each unknown carries the command that verifies it.
 
 ### `rig whoami` — compact-by-default + `--full` (`--verbose` alias)
 
@@ -543,6 +563,30 @@ rig scope slice show <slice>                          # derives read-time effect
 
 Composes with slice 33's `progress` + scaffolding to make `rig scope` the **deterministic enforcer** of `conventions/scope-and-versioning` §1 (dot-IDs) + §2 (maturity vocabulary). Agents update `stage` / `verified` / `id` through commands rather than hand-editing markdown and drifting. The `--against` MANDATORY rule on `verified` is the anti-stale keystone: bare timestamps are rejected because a bare timestamp is exactly what lets stale trackers lie while looking fresh. **STOP hand-editing the `stage` / `verified` / `id` fields in scope frontmatter; use the new verbs.** Existing missions / slices with `id:null` ghosts or missing `PROGRESS.md` are repaired idempotently via `reconcile`.
 
+### The SDLC control plane — convention sections, the two locks, `rig proof` (v0.4.4)
+
+The Living Notes UI is a plain projection of well-formed on-disk markdown. The conventions live in ONE shipped document — **`docs/reference/sdlc-conventions.md`** (in the CLI package) — and the operating procedure is the **`mission-slice-sop`** skill. The command surface:
+
+```bash
+rig scope slice create <mission> <slug> [--template <kind>]   # scaffolds ## Intent / ## Mini-requirements / ## Proof contract
+                                                              # + proof/ + PROOF.md + IMPLEMENTATION-PRD.md — EVERY template kind
+
+rig scope slice approve <slice> --scope spec                  # PLAN-LOCK: "the PRD matches my intent; this set gets built"
+rig scope slice approve <slice> --scope delivery              # PROOF-LOCK: the terminal sign-off (default scope; fires the freeze)
+
+rig proof add <slice> --artifact-type qa --verdict PASS \
+  --candidate-sha <tip> --money-evidence "<one line>" \
+  --evidences "1,3" --media "walk.webm" \
+  --self-check "<looked at it>"                               # C1 proof drop into proof/; --evidences joins the drop to its
+                                                              # proof-contract items and --media names the curated proof/-relative
+                                                              # media it stands behind (what the DELIVERED section pairs + renders)
+
+rig scope audit <mission>                                     # deterministic backstop — flags missing sections / malformed
+                                                              # proof contract / invalid C1 headers; ADVISORY, never blocks
+```
+
+The flow: intent → mini-requirements + proof contract (→ mockups for UI slices) → plan-lock → build the locked set → QA visual compare → `rig proof` drops → proof-lock. Approval is freeze/sign-off, **never** proven-green — proven-green requires recorded C1 verdicts.
+
 ### `rig skill audit` — skill cascade provenance (slice 10)
 
 ```bash
@@ -584,7 +628,7 @@ Typical operator loop:
 
 ```bash
 rig up secrets-manager --cwd /path/to/project
-rig ps --nodes --json
+rig ps --nodes --rig secrets-manager --json
 rig send vault-specialist@secrets-manager "Check Vault health and report back." --verify
 rig env status secrets-manager
 rig env logs secrets-manager
@@ -634,10 +678,12 @@ JSON form exposes `peersNote` directly for programmatic consumers.
 rig ps
 rig ps --json
 rig ps --nodes
-rig ps --nodes --json
+rig ps --nodes --rig <name> --json
+rig ps --nodes -A --json
+rig ps --nodes -A --full --json
 ```
 
-Use `rig ps --nodes --json` for the current node inventory across rigs. It is the best machine-readable operator surface for:
+Use `rig ps --nodes --rig <name> --json` for one rig's node inventory, or `rig ps --nodes -A --json` for fleet-wide projected node inventory. Use `--full` only when a downstream consumer truly needs complete per-node records. The node inventory surface carries:
 - session name
 - runtime
 - session/startup status
@@ -964,7 +1010,7 @@ rig whoami --json
 
 Notes:
 - for tmux-backed self-attach, `rig whoami --json` is the right verification
-- for raw/external self-attach, `rig ps --nodes --json` is currently the more reliable verification surface
+- for raw/external self-attach, `rig ps --nodes --rig <rigId-or-name> --json` is currently the more reliable verification surface
 - if the current shell is outside tmux, pass `--display-name <name>` when you want a stable human session label recorded
 
 ### Adopt a topology and bind live sessions
@@ -1031,13 +1077,13 @@ Verification loop:
 ```bash
 rig discover --json
 rig adopt <fragment.yaml> --bindings-file <bindings.yaml> --target-rig <rigId>
-rig ps --nodes --json
+rig ps --nodes --rig <target-rig-name> --json
 rig export <rigId> -o rig.yaml
 ```
 
 Success looks like:
 - the new sessions stop appearing in `rig discover`
-- the new logical IDs appear in `rig ps --nodes --json`
+- the new logical IDs appear in `rig ps --nodes --rig <target-rig-name> --json`
 - `rig export` includes the new pod
 
 ### Mixed-origin rigs are allowed
@@ -1055,7 +1101,7 @@ Current safety rule:
 The proven operator pattern is:
 - keep one OpenRig manager session outside the rig it manages
 - address the target by rig name, not cached rig ID
-- resolve the current owner from fresh `rig ps --nodes --json`
+- resolve the current owner from fresh `rig ps --nodes -A --json`
 - send the manager the spec path, bindings path, and verification steps with `rig send`
 
 This lets ordinary agents ask the manager for OpenRig help instead of every agent needing to be an OpenRig expert.
@@ -1152,7 +1198,7 @@ When the CLI behaves strangely, use the smallest truthful check first:
 ```bash
 rig whoami --json
 rig daemon status
-rig ps --nodes --json
+rig ps --nodes
 ```
 
 Specific operator rules:
@@ -1188,7 +1234,7 @@ Design assumptions that hold in the shipped CLI:
 
 1. `rig whoami --json`
 2. `rig transcript <your-session> --tail 100`
-3. `rig ps --nodes --json`
+3. `rig ps --nodes`
 4. `rig chatroom history <rig> --limit 50`
 
 ## Commands That Do Not Exist

package/daemon/specs/agents/shared/skills/pods/orchestration-team/SKILL.md

@@ -10,9 +10,9 @@ You are part of the orchestration pod. Your job is to keep the team productive,
 ## Startup sequence
 
 Before you summarize the rig or assign real work:
-1. Load `using-superpowers`, `openrig-user`, `orchestration-team`, `systematic-debugging`, and `verification-before-completion`.
+1. Load `using-superpowers`, `openrig-user`, `orchestration-team`, `systematic-debugging`, and `verification-before-completion`. Also load `mission-slice-sop` — the operating procedure for the canonical mission/slice files (you own PROGRESS.md `§1`; run `rig scope audit` at slice-close/mission-wrap).
 2. Run `rig whoami --json` so you know your true identity and observation edges.
-3. Run `rig ps --nodes --json` and wait for the expected starter topology to settle.
+3. Run `rig ps --nodes -A --json` (v0.4.4: `--nodes` scopes to the current rig by default; `-A` for the fleet) and wait for the expected starter topology to settle.
 4. Check recent chatroom history or direct startup messages so you know who is actually online and what they already reported.
 5. Only then announce readiness or assign work.
 
@@ -34,7 +34,7 @@ The orchestration pod is responsible for:
 **Principle:** monitoring intensity tracks **stakes × how likely you are to need to intervene, bounded to the window where that's true.** Spend tight attention only where it changes what you do, only as long as the risk lasts, then return to default. (Same evidence-not-cadence rule the `watchdog` skill applies to intervention *level*, applied to *intensity*.) **Self-test: "Can I name the stakes AND the condition that ends this close-watch?"** If not, you're hyper-monitoring.
 
 **Default (almost always) — token-efficient.** Steady-state your job is the **idle-without-handoff exception**: the queue handles normal handoff; you catch the agent who finished + went idle without closing/handing off.
-- **Status lives in the queue, not panes** (`status-not-chat-orchestrator`): `rig ps --nodes --json` + `rig queue` are your status source; do NOT reconstruct fleet-state by capturing panes (pane `rig capture` is high-bandwidth *within your own pod* — that's fine; it is not how you track cross-pod/fleet state).
+- **Status lives in the queue, not panes** (`status-not-chat-orchestrator`): `rig ps` (the consolidated map) / `rig ps --nodes -A --json` + `rig queue` are your status source; do NOT reconstruct fleet-state by capturing panes (pane `rig capture` is high-bandwidth *within your own pod* — that's fine; it is not how you track cross-pod/fleet state).
 - **The watchdog is your clock** (`watchdog`): configure `rig watchdog` to wake you (~3 min); between wakes, idle (zero tokens) — no self-run sleep-loop re-reading panes at steady-state. Prefer one workflow-watchdog + targeted exception handling over many per-seat nag loops.
 - **On each wake — cheap sweep:** `rig queue` + a *filtered* `rig ps` (see "Read cheap" below) first; ONLY for a seat that looks idle/suspicious, `rig capture <session>` last few lines (never a full pane, never huge chunks); **active owner → no-op.**
 - **Read cheap — every status command has a token cost; project to the question.** The queue-first rule is about *where* status lives; this is about *how much you pay to read it*. The token bomb is the broad unfiltered dump, not the pane capture: an unfiltered fleet-wide `rig ps --nodes --json` emits ~77k tokens — for a one-rig or one-qitem question that is almost all waste, and at watchdog cadence it burns the shared account fast.

package/daemon/specs/rigs/focused/pm-team/CULTURE.md

@@ -15,3 +15,7 @@ Ship features that solve real customer problems with evidence-backed requirement
 - PM agent is the hub. Research and code agents report to PM.
 - Coder can observe researcher output for domain context.
 - When blocked, escalate to PM rather than guessing.
+
+## Mission/slice tracking (the SDLC)
+
+Requirements and delivery are tracked as missions and slices — on-disk markdown the Living Notes UI projects. Load the packaged `mission-slice-sop` skill; the conventions live in `docs/reference/sdlc-conventions.md` (shipped with the CLI package). PM's leg of the flow: record intent verbatim, author the mini-requirements (the one-glance tier where approval starts) + the proof contract (promised deliverables as observable outcomes; UI deliverables name their planned mockup), then plan-lock with `rig scope slice approve --scope spec`. Proof-lock (`--scope delivery`) is the terminal sign-off after QA's visual compare and `rig proof add … --media` drops (the C1 drop verb).

package/daemon/specs/rigs/launch/kernel/agents/operator/agent/guidance/role.md

@@ -11,7 +11,7 @@ with them and escalate to them when ops decisions need human approval.
   rig**; other rigs require explicit operator-initiated restart.
   When the user says "bring my rigs back online":
   1. List rigs that were running pre-reboot using daemon persisted
-     state (`rig ps --json --all`) and any operator-saved roster.
+     state (`rig ps --json`) and any operator-saved roster.
   2. Confirm with the user which subset to restart.
   3. Restart each via `rig up <spec>` (or `rig restore <snapshot>`
      if a snapshot exists).

package/daemon/specs/rigs/launch/kernel/agents/operator/agent/startup/context.md

@@ -34,7 +34,7 @@ tmux sessions are gone. You own the agent-restart workflow:
 Other rigs (project rigs the user spun up) are NEVER auto-instantiated
 by the daemon. If the user asks you to bring those back:
 
-1. `rig ps --json --all` shows which rigs are persisted but with
+1. `rig ps --json` shows which rigs are persisted but with
    detached sessions.
 2. Confirm with the user which subset to restart.
 3. `rig up <spec>` for cold-start; `rig restore <snapshot> --rig

package/daemon/specs/rigs/preview/product-team/CULTURE.md

@@ -135,3 +135,7 @@ Follow patterns agents already know: docker, git, kubectl, npm.
 ## What this rig is for
 
 This is the advanced product-team lane. Use it when the work needs richer coordination than the conveyor starter. The human sets direction; the team plans, implements, reviews, and surfaces gaps honestly.
+
+## Mission/slice tracking (the SDLC)
+
+Work is tracked as missions and slices — on-disk markdown the Living Notes UI projects. Load the packaged `mission-slice-sop` skill before authoring or building a slice; the conventions (section names, proof contract, the two locks, C1 proof headers) live in `docs/reference/sdlc-conventions.md` (shipped with the CLI package). The short form: record intent → author mini-requirements + a proof contract (→ mockups for UI slices) → plan-lock (`rig scope slice approve --scope spec`) → build the locked set → QA visually compares planned vs delivered → `rig proof add … --evidences --media` drops (the C1 drop verb — never hand-place evidence) → proof-lock (`--scope delivery`). `rig scope audit` is the advisory backstop — fix the flag, don't suppress it.

package/dist/build-info.d.ts

@@ -0,0 +1,8 @@
+export interface BuildInfo {
+    semver: string | null;
+    commit: string | null;
+    dirty: boolean | null;
+    builtAt: string | null;
+}
+export declare const BUILD_INFO: BuildInfo;
+//# sourceMappingURL=build-info.d.ts.map

package/dist/build-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-info.d.ts","sourceRoot":"","sources":["../src/build-info.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,eAAO,MAAM,UAAU,EAAE,SAKxB,CAAC"}

package/dist/build-info.js

@@ -0,0 +1,11 @@
+// GENERATED by scripts/build-package.sh — the packaged build-identity stamp.
+export const BUILD_INFO = {
+  semver: "0.4.4",
+  commit: "ac75777a3cad318592dae9d616a09d824f1398e5",
+  dirty: false,
+  builtAt: "2026-07-06T08:21:05Z",
+};
+export function stampFields(info = BUILD_INFO) {
+  if (!info.commit) return {};
+  return { semver: info.semver, commit: info.commit, dirty: info.dirty, builtAt: info.builtAt };
+}

package/dist/build-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-info.js","sourceRoot":"","sources":["../src/build-info.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,EAAE;AACF,uEAAuE;AACvE,qEAAqE;AACrE,4EAA4E;AAC5E,6EAA6E;AAC7E,yDAAyD;AASzD,MAAM,CAAC,MAAM,UAAU,GAAc;IACnC,MAAM,EAAE,IAAI;IACZ,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,IAAI;IACX,OAAO,EAAE,IAAI;CACd,CAAC"}

package/dist/commands/compact.d.ts

@@ -0,0 +1,15 @@
+import { Command } from "commander";
+import { DaemonClient } from "../client.js";
+import { type LifecycleDeps } from "../daemon-lifecycle.js";
+export interface CompactDeps {
+    lifecycleDeps: LifecycleDeps;
+    clientFactory: (url: string) => DaemonClient;
+}
+/**
+ * OPR.0.4.3.14 — `rig compact <session>`: manually run the guided compaction
+ * lifecycle (prep → /compact → restore → audit) for one Claude seat, on demand,
+ * independent of the auto threshold. Distinct from the read-only `rig
+ * compact-plan` triage command.
+ */
+export declare function compactCommand(depsOverride?: CompactDeps): Command;
+//# sourceMappingURL=compact.d.ts.map

package/dist/commands/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../src/commands/compact.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,YAAY,EAAuB,MAAM,cAAc,CAAC;AACjE,OAAO,EAAiC,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAQ3F,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,aAAa,CAAC;IAC7B,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,YAAY,CAAC;CAC9C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,YAAY,CAAC,EAAE,WAAW,GAAG,OAAO,CAyDlE"}

package/dist/commands/compact.js

@@ -0,0 +1,62 @@
+import { Command } from "commander";
+import { DaemonClient, terminalAuthHeaders } from "../client.js";
+import { getDaemonStatus, getDaemonUrl } from "../daemon-lifecycle.js";
+import { realDeps } from "./daemon.js";
+// The trigger is two-phase (prep → wait-for-idle → /compact); the wait-for-idle
+// half can take up to the daemon's manual-prep ceiling (~120s). Give the HTTP
+// call generous headroom so the client does not time out mid-sequence.
+const MANUAL_COMPACT_REQUEST_TIMEOUT_MS = 180_000;
+/**
+ * OPR.0.4.3.14 — `rig compact <session>`: manually run the guided compaction
+ * lifecycle (prep → /compact → restore → audit) for one Claude seat, on demand,
+ * independent of the auto threshold. Distinct from the read-only `rig
+ * compact-plan` triage command.
+ */
+export function compactCommand(depsOverride) {
+    const cmd = new Command("compact")
+        .description("Manually run the guided compaction sequence (prep → /compact → restore → audit) for one Claude seat")
+        .argument("<session>", "Target Claude session name (e.g. dev-impl@my-rig)")
+        .option("--json", "JSON output for agents")
+        .addHelpText("after", `
+Examples:
+  rig compact dev-impl@my-rig          Manually compact one Claude seat now
+  rig compact dev-impl@my-rig --json   JSON output for agents
+
+Runs the SAME guided lifecycle the auto-compaction policy runs (pre-compact
+prep → /compact with the trust-bridge → restore-from-marker → read-depth audit)
+on demand, for ONE Claude seat, without waiting for the context threshold. It is
+NOT a bare /compact and NOT the read-only 'rig compact-plan' triage. Non-Claude
+seats are rejected. The /compact is sent only AFTER the prep turn completes.`);
+    const getDepsF = () => depsOverride ?? {
+        lifecycleDeps: realDeps(),
+        clientFactory: (url) => new DaemonClient(url),
+    };
+    cmd.action(async (session, opts) => {
+        const deps = getDepsF();
+        const status = await getDaemonStatus(deps.lifecycleDeps);
+        if (status.state !== "running" || status.healthy === false) {
+            console.error("Daemon is not running. Start it with: rig daemon start");
+            process.exitCode = 1;
+            return;
+        }
+        const client = deps.clientFactory(getDaemonUrl(status));
+        const res = await client.post("/api/compaction/trigger", { session }, { headers: terminalAuthHeaders(), timeoutMs: MANUAL_COMPACT_REQUEST_TIMEOUT_MS });
+        if (opts.json) {
+            console.log(JSON.stringify(res.data));
+            if (res.status >= 400)
+                process.exitCode = res.status >= 500 ? 2 : 1;
+            return;
+        }
+        if (res.status >= 400) {
+            const error = res.data["error"];
+            console.error(error ?? `Manual compaction failed (HTTP ${res.status})`);
+            process.exitCode = res.status >= 500 ? 2 : 1;
+            return;
+        }
+        const stage = res.data["stage"];
+        console.log(`Manual compaction triggered for ${session}${stage ? ` (stage: ${stage})` : ""}.`);
+        console.log("The restore + read-depth audit prompts follow automatically as the seat drains below threshold.");
+    });
+    return cmd;
+}
+//# sourceMappingURL=compact.js.map