@openrig/cli 0.6.10 → 0.6.12

package/daemon/assets/plugins/openrig-core/skills/mission-slice-sop/SKILL.md

@@ -66,7 +66,7 @@ These three are a division of labour, not a chain of gates. One agent may hold a
 ### PROGRESS.md
 - **WHO:** the orchestrator owns the current state; every agent logs its own outcomes.
 - **WHEN:** on material delivery-state changes and at acceptance.
-- **HOW:** keep current delivery state in `## Current state`; append material outcomes with links to proof under `## Outcomes`. Retain historical entries and existing checkboxes without treating them as current acceptance authority. For a selected proof policy, use `rig proof show <slice>` for current readiness; keep frontmatter `stage`/`verified` honest.
+- **HOW:** keep current delivery state in `## Current state`, naming who the next move waits on, and check that against the source (the PR on GitHub, the queue) before you rely on it; append material outcomes with links to proof under `## Outcomes`. Retain historical entries and existing checkboxes without treating them as current acceptance authority. For a selected proof policy, use `rig proof show <slice>` for current readiness; keep frontmatter `stage`/`verified` honest.
 
 ### PROOF.md + proof/
 - **WHO:** the impl/QA pair that worked the slice.
@@ -90,6 +90,15 @@ End every turn by passing the ball — a `rig queue handoff` to the next agent.
 
 Never go idle holding a baton.
 
+## Records
+
+The rules for recording a slice's state are in the conventions SSOT (`docs/reference/sdlc-conventions.md` in the OpenRig source repository, `$OPENRIG_HOME/reference/sdlc-conventions.md` when installed). Read them before you stamp, judge or report:
+
+- **Stamps, stages and proof:** A2 (`rig proof judge`, `rig scope slice stage` and `verified`) and B2–B3 (`rig scope slice approve --scope spec|delivery`, `rig proof add` and `--candidate-sha`).
+- **Built and merged:** the release-mission paragraphs of A1 (`candidate:<sha>`, `merged:<pr-number>`, `arrangement.source.integration_ref`).
+- **Dispatch data:** the DISPATCH DATA row of the component menu (the `worktree_path=` body line).
+- **Editing judged evidence resets the judgment.** An accepted `rig proof judge` records the sha256 of the evidence it cites; edit that evidence (the cited section, when it cites a heading), the contract item's text or the scope's proof policy, and the item reads `unknown` until you judge it again.
+
 ## Verify (deterministic backstop)
 
 Run `rig scope audit` at slice-close. Every convention check is **advisory / fail-open** — it records and advises, never blocks a write. Fix what's real, skip what isn't, keep moving. **A clean audit score is not required to proceed.**

package/daemon/assets/plugins/openrig-core/skills/openrig-skills/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: openrig-skills
-description: "Use when you're operating OpenRig and need the right skill or context for fleet recovery, seat handover, new-seat orientation, a watchdog wake, cross-host reach to an agent on another machine, rig packaging, an OpenRig upgrade, systematic debugging, queue triage, or implementation planning; also use when you don't know what applies or nothing is projected on cold boot."
+description: "Use when an agent running inside OpenRig needs the right skill or context for fleet recovery, seat handover, new-seat orientation, a watchdog wake, cross-host reach to an agent on another machine, rig packaging, an OpenRig upgrade, systematic debugging, queue triage, or implementation planning; also when the agent doesn't know what applies or nothing is projected on cold boot. Installing, starting or updating OpenRig, getting back to a team or bringing a stopped one back from a person's own session is the rigs skill."
 allowed-tools: Bash(rig:*)
 metadata:
   openrig:
@@ -53,7 +53,7 @@ These are auto-delivered to every rig; their name+description are already in you
 - **openrig-user** — you need a `rig` CLI command (send / queue / ps / whoami / scope / broadcast). The daily CLI surface.
 - **applying-a-permission-policy** — a rig or seat has a permission policy attached, or you're setting one up: translate it into the live harness configuration.
 - **claude-compaction-restore** — you just compacted (Claude). Restore from durable evidence before resuming real work.
-- **delegating-work** — deciding who should do a task: you, a spawned subagent, or a durable peer seat that already holds the context.
+- **delegating-work** — deciding who should do a task (you, a spawned subagent, or a durable peer seat that already holds the context), and how to brief the agent you hand it to, which depends on the model it runs.
 - **loading-addressable-markdown** — a task names Markdown as `path#h2-slug` or `path#h2-slug/h3-slug` outside the context-pack library.
 - **session-compaction-and-restore** — preparing for, or recovering from, compaction (any runtime). The write- and read-side protocol.
 - **queue-handoff** — you're passing durable work to another seat or ending your turn. The queue is the work ledger, not chat.

package/daemon/assets/plugins/openrig-core/skills/openrig-user/SKILL.md

@@ -54,7 +54,8 @@ Use for any substantive work that must not fall through chat — slice handoffs,
 guard verdicts, QA results, full-tip reviews, multi-item batches. Survives agent
 restarts. Tracked in the daemon SQLite schema. Surfaces in Project / queue views
 + in the destination seat's inbox. Tag with mission / slice / gate / checkpoint
-so future-you (and any peer) can find it.
+so future-you (and any peer) can find it. Give the row a `--summary` (its subject, wherever the row is listed)
+and the `project:`, `mission:` and `slice:` tags when it is project work.
 
 Body discipline: substantive bodies go through **`--body-file <path>`** (or `-` for stdin) — the
 purpose-built, corruption-safe surface (it kills the backtick-shell-corruption class for multi-line
@@ -66,7 +67,8 @@ Example:
 ```bash
 rig queue create \
   --destination dev-reviewer@example-project \
-  --tags "mission:data-import,slice:import-report" \
+  --summary "Review the import report: it changes how rows are deduplicated" \
+  --tags "project:example-project,mission:data-import,slice:import-report" \
   --body-file /tmp/import-report-handoff.md
 ```
 
@@ -83,7 +85,8 @@ Example:
 ```bash
 rig queue handoff <qitem-id> \
   --to dev-reviewer@example-project \
-  --tags "mission:data-import,slice:import-report" \
+  --summary "Review the import report: it changes how rows are deduplicated" \
+  --tags "project:example-project,mission:data-import,slice:import-report" \
   --body-file /tmp/import-report-handoff.md
 ```
 
@@ -355,12 +358,16 @@ restore) into one call.
 
 ```bash
 rig start                    # interactive: daemon + kernel + pick-and-restore
-rig start --last             # headless: restore all rigs that were last running
+rig start --last             # headless: restore rigs that were last running; a rig stopped on purpose stays down
 rig start --all              # headless: restore all rigs with restore-usable snapshots
 rig start --rigs <name> [<name>...]   # headless: restore only the named rigs
 rig start --json             # JSON output for agents
 ```
 
+`rig start --last` keeps down a rig that was stopped on purpose (`rig down` or `rig seat stop`).
+Bring it back with `rig start --rigs <rig>`. A rig whose seat statuses can't be read is still
+attempted, with a warning (`seat_status_unreadable`).
+
 Framing: `rig start` is the RECOVERY entry point, not the getting-started
 hero. The fresh-user boot hero remains `rig up <team>` (typically
 `rig up starter` for a first change, or `rig up factory`). Reach for `rig start` after a host reboot, daemon
@@ -500,11 +507,12 @@ rig ps --active             # opt-in active-state filter (does NOT change the al
 ```bash
 rig whoami                  # compact: identity + peers names + edges + transcript path
 rig whoami --json           # compact JSON
+rig whoami --json --all-peers  # compact JSON with every peer, when output.compact bounds the list
 rig whoami --full           # complete payload (v0.3.4 default shape)
 rig whoami --verbose        # alias of --full
 ```
 
-The first command every agent runs on boot AND every compaction-restore. The compact default keeps identity-recovery essentials (`identity`, `peers` names + sessionNames, `edges` directional `kind` + `to.sessionName`, `transcriptPath`). `--full` adds `contextUsage`, `commands`, `peersNote`, `runtimeContext`. The compact-default is an ALLOWLIST projection — future payload fields default to `--full` and cannot silently re-bloat the every-boot path.
+The first command every agent runs on boot AND every compaction-restore. The compact default keeps identity-recovery essentials (`identity`, `peers` names + sessionNames, `peersNote`, `edges` directional `kind` + `to.sessionName`, the transcript path). `--full` adds `contextUsage`, `commands`, `runtimeContext` and `workspace`. With `output.compact` on, compact JSON lists at most `output.whoami_peers` peers (default 8): edge peers first, then your pod, then roster order. `peersNote` and `peersOmitted` then say how many were left out, and `--all-peers` lists every one; `edges` stays complete. The compact-default is an ALLOWLIST projection — future payload fields default to `--full` and cannot silently re-bloat the every-boot path.
 
 ### `rig queue list` — active-frontier + docker/kubectl grammar
 
@@ -519,7 +527,7 @@ rig queue list --mine                # just the caller's items
 rig queue list --destination <s>     # destined to <s>
 rig queue list --source <s>          # sourced by <s>
 rig queue show <qitemId>             # bounded single-item body preview
-rig queue show <qitemId> --full      # complete body and chain fields
+rig queue show <qitemId> --full      # complete body and chain fields; a closed row adds closingTransition (the close's state, reason, target, actor, time and note)
 ```
 
 Four orthogonal axes (scope × history × field-breadth × encoding), all composable. **STOP using bare `rig queue list` as the cross-rig firehose.** Default is now active + compact + current-rig. Cross-rig history with full bodies is opt-in via `-A -a --full`; request only the breadth and fields needed for the question.
@@ -938,6 +946,88 @@ rig auth seats … --runtime codex         # seat -> profile registry (metadata
 
 **Hard secret boundary:** no token value is ever printed, logged, queued, streamed, or committed; status/validate report presence/mode/login-state only; seat labels are metadata, not live-account proof. MVP is `--runtime codex`; other runtimes use the same surface with a different `--runtime`, never a parallel command.
 
+### Manage subscriptions across a fleet (when the person asks you to)
+
+**This applies only when both hold:**
+- the daemon's `provider.subscription_moves` setting is on. It's off by default; the person turns it on with
+  `rig config set provider.subscription_moves true`;
+- the person has asked you to manage their subscriptions.
+
+Otherwise, don't take this job on. Installing or upgrading OpenRig appoints no agent, launches no bundle and starts no
+rotation.
+
+When a person runs several Claude and Codex subscriptions across machines, the fleet studio bundle's one agent is meant
+to keep work running, through the Fleet app. Until that bundle is available, the agent the person asks to manage their
+subscriptions can use this section. If that's you, you decide which subscription or home moves, and when. You decide
+from:
+- the usage and assignment readings, and their freshness;
+- the move record;
+- the person's standing preferences.
+
+You say why, and you see the outcome through. OpenRig gives you the facts and the tools; it never decides for you,
+and there's no threshold to obey.
+
+**Who decides:**
+- **The person's operator agent** can ask you for a move, or look at the record. It doesn't make competing moves of
+  its own.
+- **One agent manages subscriptions:** the one the person asked, or the fleet studio's agent once that bundle is
+  available. There's no other fleet-manager role and no automatic manager. Use the commands below directly; no extra
+  hand-off is needed.
+- **The Observatory is optional:** it can show your moves and readings, but you don't need it to rotate.
+
+**The unit is a Codex home, with every seat on it.** Moving some seats on a shared home to a different account, and
+moving Claude seats, aren't supported moves yet: say so instead of improvising.
+
+1. **Know the subscriptions.**
+   - Each subscription is reached through a saved profile on a home (`rig auth list` and `rig auth save`) on each
+     machine. Which seats use which profile is `rig auth seats`, and that's metadata: not proof of a live account.
+   - Check you can read each subscription's usage, and name any you can't.
+2. **Read before deciding.**
+   - Use `rig provider status --all-hosts --json` (add `--refresh` for fresh native readings). Each allowance has
+     its windows, reset times and when it was observed.
+   - **One allowance seen on two machines is one allowance:** never add its headroom twice.
+   - **A stale reading** is usable only with its age recorded, or after a refresh.
+   - **An unknown or unavailable reading is never room.**
+   - **Equal reset times don't mean the same account.**
+   - **A seat's link to a subscription is observed, configured or unknown.** Only an observed link shows the seat
+     actually uses it; a configured one (a profile, a registry row) is a claim.
+3. **Decide, and leave seats alone for a reason.**
+   - `rig seat restart <seat> --keep-conversation --plan` shows what a restart keeps, and every peer on the same
+     home. Moving the home moves them all.
+   - Skip a seat that's mid-turn, running a service, or about to finish, and record why.
+   - The person's standing preferences ("never move the reviewers") are yours to follow and record.
+4. **Move the home.**
+   - On that machine, `CODEX_HOME=<that home> rig auth switch <profile> --runtime codex`. `rig auth` acts on
+     `CODEX_HOME`, or on the default home, and `rig auth status` prints which home it means: check it before
+     switching.
+   - Then restart each chosen seat: `rig seat restart <seat> --keep-conversation --reason "<why>"`.
+   - After it completes a real tool-using turn, check it: `rig seat restart <seat> --keep-conversation --verify
+     --expect-account <the target's Account line>`. `--verify` only checks; it never restarts. Only that check
+     reports `moved`, and anything less is unconfirmed.
+   - **A slow reply isn't a failure:** never restart a seat a second time. Follow up at your next look.
+5. **Record every move, partial or unconfirmed included,** with `rig provider moves record --file <move.json>`
+   (`--help` shows the shape):
+   - the home and machine;
+   - from and to, as labels;
+   - your reason;
+   - each reading you acted on, with its observation time;
+   - each seat's result (`moved`, `unconfirmed` or `unknown`) with its evidence or what's missing;
+   - the peers, for example "not restarted; account unverified".
+
+   A seat marked `moved` needs its `evidence`, and an `unconfirmed` or `unknown` one needs what's `missing`. A home
+   switched with every seat left as a peer is still a move to record, with `seats: []`. A follow-up that confirms an
+   earlier unconfirmed seat records a new move with `supersedes`. Asked "why did this
+   seat move?", answer from `rig provider moves --seat <seat>`. Never put credentials in a record.
+6. **When a sign-in is needed:**
+   - Ask the person once, durably: a queue item to their seat, naming the machine and the subscription.
+   - Move nothing onto that subscription until it's done.
+   - On later wakes, check that item instead of asking again. Carry on with everything else.
+7. **When nothing has room:** say so, with the reset times. Never fall back to an API key, buy anything, or create an
+   account.
+
+**What wakes you:** a watchdog, a usage-limit park on the queue, or the person asking. How often you look is your
+judgment within those.
+
 ## Context packs and paced delivery (0.5.0)
 
 **Compose context once, hand it to a seat cleanly.** A library primitive plus a set of delivery flags. The rule that keeps the grammar coherent — internalize this one: **the noun stores and composes; the verbs deliver.** `rig context` never sends anything; delivery is only ever `rig send` / `rig broadcast` / `rig walk` / `rig queue`.
@@ -984,7 +1074,8 @@ Walk a seat *through* a pack: each piece is sent into the pane, spaced by `--pac
 - **The orchestrator habit — assign work *with* its context attached:**
   ```bash
   rig context compose --out packs/qitem-brief --from <brief-file> <proof-file>
-  rig queue create --destination dev-driver@build --body-context packs/qitem-brief --summary "…"
+  rig queue create --destination dev-driver@build --body-context packs/qitem-brief \
+    --summary "…" --tags "project:<id>,mission:<id>,slice:<id>"
   ```
   Replace `<brief-file>` and `<proof-file>` with your existing local files. The curated context rides the durable handoff, survives compaction, and is auditable.
 
@@ -1280,8 +1371,8 @@ This lets ordinary agents ask the manager for OpenRig help instead of every agen
 ```bash
 rig grow <rig-id> <member...> [--pod <pod> | --new-pod <pod>] [--runtime <runtime>] [--cwd <path>] [--json]
 rig expand <rig-id> <pod-fragment-path> [--rig-root <path>] [--json]
-rig launch <rigId> <nodeRef> [--json]
-rig launch <rigId> --seats <a,b,c> [--hold-reason <text>] [--json]
+rig launch <rig> <nodeRef> [--json]
+rig launch <rig> --seats <a,b,c> [--hold-reason <text>] [--json]
 rig remove <rigId> <nodeRef> [--json]
 rig shrink <rigId> <podRef> [--json]
 rig unclaim <sessionRef> [--json]
@@ -1294,8 +1385,9 @@ or `rig add` (one member) when a seat needs an explicit model, a permission poli
 different agent spec or role profile, per-seat runtime or cwd, or startup files.
 
 Node-granular managed partial restore (v0.3.4+):
-- `rig launch <rigId> <nodeRef>` relaunches a single seat by logical id or node id through orchestration.
-- `rig launch <rigId> --seats <a,b,c>` relaunches a comma-separated subset of seats.
+- `rig launch <rig> <nodeRef>` relaunches a single seat by logical id or node id through orchestration. `<rig>` is the
+  rig's name or ID; a name shared by more than one active rig stops with the candidate IDs.
+- `rig launch <rig> --seats <a,b,c>` relaunches a comma-separated subset of seats.
 - `--hold-reason <text>` records a reason for holding non-target seats during the partial launch.
 - This is a SUPPORTED managed path. The prior `pod_aware_launch_unsupported` dead-end is retired; pod-aware narrow launch now goes through this surface rather than ad-hoc rebuilds.
 
@@ -1370,6 +1462,75 @@ Current shipped MCP tools:
 - `rig_capture`
 - `rig_chatroom_send`
 - `rig_chatroom_watch`
+- `rig_add`
+- `rig_queue_create`, `rig_queue_show`, `rig_queue_list`, `rig_queue_claim`, `rig_queue_update`
+
+The server acts as one seat: the `OPENRIG_SESSION_NAME` in its environment. Every request carries that identity, so
+no tool call names a sender. Without it, writes that need an actor are refused with `actor_required`.
+
+### Join a team from an agent with no terminal of its own (desktop apps)
+
+An agent in a desktop app can work with a team as a seat through this MCP server. If the app gives it a shell, it can
+use the `rig` CLI instead, the same way.
+
+1. **Attach once.** With its shell, or by asking the person to run it:
+   `rig attach --self --rig <rigId> --pod <namespace> --member <name> --runtime <runtime> --print-env`.
+   Note the `OPENRIG_SESSION_NAME` it prints.
+2. **Give the person the MCP entry to add.** Don't edit their app's settings yourself. The entry runs
+   `rig mcp serve`, with `OPENRIG_SESSION_NAME=<that seat>` in its environment. Most MCP clients take it as a
+   command, arguments and an `env` map.
+3. **Hand off work** with `rig_queue_create`, and keep the `qitemId` it returns.
+4. **Read the answer** with `rig_queue_show <qitemId>`. The item's state, closure and transition notes are where the
+   assignee records it. A call that times out has an unknown outcome: check `rig_queue_show` with the same id
+   before you retry, and retry only with that id.
+5. **Take work** with `rig_queue_list` (`owned: true`), `rig_queue_claim` and `rig_queue_update`. Close with the
+   answer in `note`.
+
+Limits today:
+- **OpenRig can't wake this agent itself.** `rig send` to an attached external node is refused, and a task's nudge to
+  it is unroutable. It sees new work when it checks `rig_queue_list`, or, if its app can run background shell
+  commands, with the opt-in wait below.
+- **Proven surfaces:** treat each app, and each mode inside one, as unproven until it has been run there.
+
+#### Wake on new work (opt-in; off unless the person turns it on)
+
+An agent whose app can run a shell command in the background, and starts a new turn when that command finishes, can
+wait for its own work. Claude Code, including Claude Desktop's Code tab, does this.
+
+- **Only if the person has said they want teammates to be able to wake this session.** Never turn it on yourself, and
+  never change their settings for it.
+- The shell needs this seat's identity: export the `OPENRIG_SESSION_NAME` that the one-time attach printed.
+- Start this as a background command, then end your turn. Don't poll it yourself.
+
+```sh
+# Waits until a task is assigned to this seat, prints it and exits; ends after MAX seconds.
+max=${MAX:-3300}; every=${EVERY:-5}; end=$(( $(date +%s) + max )); checked=0; failing_since=""
+while [ "$(date +%s)" -lt "$end" ]; do
+  if out=$(rig queue list --owned --state pending --json 2>/dev/null); then
+    checked=1; failing_since=""
+    case "$out" in *'"qitemId"'*) printf 'NEW WORK: %s\n' "$out"; exit 0 ;; esac
+  elif [ -z "$failing_since" ]; then
+    failing_since=$(date -u +%H:%M:%SZ)
+  fi
+  sleep "$every"
+done
+why="Run rig queue list --owned to see why (this seat's identity, the daemon) before starting the wait again."
+if [ "$checked" = 0 ]; then
+  echo "Couldn't check for work: every poll failed. $why"; exit 1
+elif [ -n "$failing_since" ]; then
+  echo "Checking stopped working at $failing_since: every poll since then failed. $why"; exit 1
+fi
+echo "No new work before the deadline. Start the wait again."
+```
+
+- **When it wakes you with `NEW WORK`:** `rig queue claim` each item, do it, and close it with the answer. Then start
+  the wait again and end your turn.
+- **Don't leave an item you've seen pending:** it wakes you again at once. Claim it, block it or hand it off.
+- **A failed poll doesn't end the wait;** only new work or the deadline does.
+- **If every poll failed, or every poll since some point did** (the daemon stopped mid-wait), it says so, with when,
+  and exits non-zero instead of reporting no work. A failure followed by a successful poll stays quiet. Find out why
+  with `rig queue list --owned` (usually this seat's identity, or the daemon) before starting the wait again.
+- **If your app stops the background command, or you start a new session,** start the wait again.
 
 ## Troubleshooting and Weird States
 

package/daemon/assets/plugins/openrig-core/skills/orienting-to-an-inherited-seat/SKILL.md

@@ -180,10 +180,13 @@ reconcile. **This is the feature a handover has and a compaction does not** —
 - **Ask across the three levels** — the base verb `rig ask <rig|target> "<question>"` takes a level flag:
   - `--seat <session-name>` — search a **seat's transcript** (the seat-scoped record).
   - `--session <token>` — search a specific **session's JSONL** by token.
-  - `--wake <seat[@gen] | token>` — **wake** that tenure: resume it to reason a *fresh* answer (the
-    expensive level, distinct from the two cheap searches). A `seat@gen` ref resolves through the
-    lineage ledger; an unresolvable ref's refusal **teaches you the available tenures**. This is the
-    ergonomic wrapper for the manual resume in the floor above.
+  - `--wake <target>` — **wake** that tenure: resume it to reason a *fresh* answer (the
+    expensive level, distinct from the two cheap searches). Wake seat targets must include the rig:
+    `member@rig` or `member@rig@N` (1 = newest tenure). Seat refs resolve from that seat's `sessions`
+    rows, newest first; an unresolvable ref's refusal **teaches you the available tenures**.
+    A two-part target such as `x@2` is a seat name, not a generation selector.
+    Values without `@` go unchanged to the runtime as a session ID or title; a bare member
+    name is not resolved within `<rig>`. This is the ergonomic wrapper for the manual resume above.
   Reach for the cheap transcript / JSONL searches first; **wake only when you need reasoning the record
   does not already hold.**
 - **`rig ask --wake` wraps the harness resume and is not yet well-exercised.** If it errors, hangs

package/daemon/assets/plugins/openrig-core/skills/queue-handoff/SKILL.md

@@ -114,6 +114,14 @@ reaching for `--notify`, stop — that flag does not exist on the
 shipped 0.3.1 CLI; you may be following a stale instruction that
 inverted the default-nudge polarity.
 
+## Every queue row
+
+- **`--summary "<what it is and why this seat>"`** on every `create`, `handoff` and `handoff-and-complete`: one or two plain sentences. It is the row's subject in RECENT, the story and the needs-you view, and a handoff does not inherit it from the source row.
+- **Scope tags `project:<id>`, `mission:<id>`, `slice:<id>`** on project work, set when you create the row (`--tags`; `create` also takes `--mission` and `--slice`). Tags can't be edited afterwards. A handoff keeps the source row's tags unless you pass `--tags` or `--gate`, either of which replaces them; repeat the scope tags in `--tags` when you use `--gate`.
+- **Pass work on with `handoff-and-complete`.** It closes your row as done and records the next row as its successor in one step. A `create` followed by `update --state done --closure-reason handed_off_to` records no successor, and the stuck sweep raises a recovery item for it.
+- **Close what you hold.** A row you claimed ends in a handoff or an `update --state done --closure-reason …`; `rig queue overdue` lists claimed rows past their deadline.
+- **Brief for the model that will read it.** Before handing a peer open-ended work, check which model it runs: `delegating-work`, "Check what kind of agent you're handing it to".
+
 ## Queue-body hygiene (token + parse safety)
 
 The qitem body is durable DATA the daemon stores and replays on every

package/daemon/assets/plugins/openrig-core/skills/refocusing/scripts/trace-to-root.py

@@ -351,7 +351,12 @@ def render_held_and_next(evidence):
             missions = ", ".join(row.get("missions") or [])
             output.append(f"- {row.get('qitemId') or 'a row'} — {row.get('summary') or 'no summary'}"
                           + (f" [mission: {missions}]" if missions else ""))
-    if evidence.get("heldAndNextTruncated"):
+    if "heldTruncated" in evidence or "nextTruncated" in evidence:
+        if evidence.get("heldTruncated"):
+            output.append("(the held list was cut; `rig queue list --owned --state blocked` has the rest)")
+        if evidence.get("nextTruncated"):
+            output.append("(the next list was cut; `rig queue list --owned --state pending` has the rest)")
+    elif evidence.get("heldAndNextTruncated"):
         output.append("(held and next lists were cut; `rig queue list` has the rest)")
     return "\n".join(output)
 

package/daemon/assets/plugins/openrig-core/skills/retiring-and-inheriting-a-seat/SKILL.md

@@ -137,8 +137,11 @@ generation's session token → resume it for **one question**, then let it sleep
 - Claude: `claude -p --resume <session>`
 - Codex: `codex exec` (resume the rollout)
 
-Use `rig ask <rig> "<q>" --wake <seat[@gen]|token>` for an explicit bounded
-consultation (introduced in CLI 0.5.1). Check `rig ask --help` for `--runtime`
+Use `rig ask <rig> "<q>" --wake <target>` for an explicit bounded consultation
+(introduced in CLI 0.5.1). Wake seat targets must include the rig: `member@rig` or
+`member@rig@N` (1 = newest tenure). Values without `@` go unchanged to the runtime
+as a session ID or title; a bare member name is not resolved within `<rig>`.
+Check `rig ask --help` for `--runtime`
 and `--wake-timeout`. The wrapper uses a runtime resume; its presence is not
 proof that a particular retained history is available. For a Claude history,
 `claude -p --resume <full-uuid>` is the runtime-level fallback when supported.

package/daemon/assets/plugins/openrig-core/skills/session-compaction-and-restore/SKILL.md

@@ -79,6 +79,25 @@ OpenRig activity **hooks** and `[features]`, never session or auth state. So the
 rule is "never edits native session/auth/transcript files," NOT "never touches any
 provider-owned file."
 
+## Claude's own idle compaction while managed compaction is on
+
+While `policies.claude_compaction.enabled` is true with a valid threshold (the enforcer treats any other
+threshold as off), every Claude session OpenRig launches (fresh, fork, resume and restore; ordinary, kernel,
+team-default and full-bypass seats) carries `idleCompaction: false` in its one `--settings` value. Claude Code then
+doesn't compact an idle session on its own, so managed seats compact through OpenRig's sequence (restore map, then
+`/compact` at the threshold).
+
+- **Version boundary:** Claude Code supports the key from 2.1.290. Earlier versions ignore it, so idle compaction
+  stays possible there.
+- **Precedence:** it overrides a lower-precedence `idleCompaction: true` in user or project settings for those
+  launches. Claude's managed settings still win.
+- **Native threshold auto-compaction is untouched** (`autoCompactEnabled`, `DISABLE_AUTO_COMPACT`). Where the enforcer
+  has no fresh status-line usage sample for a seat, it doesn't compact that seat, and native auto-compaction is then
+  the only compaction. Nothing guarantees a native fallback.
+- **It applies at the next launch.** Turning the policy off leaves idle compaction off in a running session until
+  that session's next launch. Turning it on doesn't reach sessions already running.
+- **Policy off, or a non-Claude runtime:** the launch command is unchanged.
+
 ## Current CLI surface (operator / kernel seats; verified vs main d37a08ad)
 
 Managed compaction/restore is driven by five shipped verbs — pick per intent, and

package/daemon/assets/skills/rigs/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rigs
-description: Use when the user mentions OpenRig, rigs or the rig command, or wants a team of coding agents (Claude Code, Codex) on their project. That includes installing, setting up, starting or updating OpenRig, seeing or getting back to their OpenRig agents, TUI or operator, starting or sharing a team, and joining this session to one.
+description: Use when a person in their own Claude Code or Codex session mentions OpenRig, rigs or the rig command, or wants a team of coding agents (Claude Code, Codex) on their project. That includes installing, setting up, starting or updating OpenRig, seeing, getting back to or re-attaching to their OpenRig agents (including bringing a stopped team back), TUI or operator, starting or sharing a team, and joining this session to one. Operating a running rig from inside it (fleet recovery, seat handover, watchdog wakes, in-rig upgrades) is the openrig-skills skill.
 ---
 
 # rigs: your route into OpenRig
@@ -24,8 +24,13 @@ guidance in `AGENTS.md` or `CLAUDE.md` plus the team's skills and plugins. Say s
 - **Check first:** `rig --version`. If it prints a version, go to step 2.
 - **What it needs:** macOS or Linux, Node.js 22 or 24, tmux, and Claude Code or Codex signed in. Check only what's
   missing: `node --version`, `tmux -V`, `claude auth status` or `codex login status`.
-- **Install:** `npm install -g @openrig/cli`, then `rig preflight` (Node, tmux, the daemon port and state folders)
-  and `rig doctor`.
+- **A check that needs the network** (`gh auth status`, a registry or other fetch) can fail falsely in a sandbox without
+  network access, such as Codex's default one. Re-run that one command with network access before you tell the person
+  to sign in again or fix anything.
+- **Install:** `npm install -g @openrig/cli`, then `rig setup --providers codex` (or `claude`, or `both`: the harness
+  the person uses). Setup checks Node, tmux and the logins. It installs tmux (with Homebrew, when present) or the chosen
+  harness (with npm) if either is missing, installs Herdr for the OpenRig view unless they decline it (`--no-herdr`),
+  and adds an OpenRig block to `~/.tmux.conf`, so say all of that first. It doesn't start the daemon. Then `rig doctor`.
 - **Then go on to step 2:** say it's installed and ask what they want worked on, and in which repository. A plain
   "install OpenRig" includes this. Stop here only if they say not to start a team.
 - **If something fails:** `rig context get help` is the help guide for the installed version. If `rig` itself won't
@@ -36,6 +41,8 @@ guidance in `AGENTS.md` or `CLAUDE.md` plus the team's skills and plugins. Say s
 - **Start OpenRig:** `rig daemon status`, and `rig daemon start` if it isn't running. `rig preflight` and `rig doctor`
   don't start it. Starting it also starts OpenRig's own team, the kernel, whose operator sets up the person's team.
   Keep it.
+- **If the person uses Codex:** now that OpenRig is running, make the one-time offer under "Codex: one offer, once,
+  after OpenRig starts" at the end of this step.
 - **Show them OpenRig, the handoff:** once OpenRig is running, open the OpenRig TUI and operator for the person. Say
   you're opening it, then run `rig terminal open saved:kernel --window` on the daemon's desktop. This is the next step
   after installing or starting OpenRig, and the way back whenever they want their agents or OpenRig again. Don't wait
@@ -75,6 +82,26 @@ guidance in `AGENTS.md` or `CLAUDE.md` plus the team's skills and plugins. Say s
 
   For any other failure, the table under "What can interrupt installation and the OpenRig view" in
   `rig context get reference/getting-started.md#open-the-kernel-conversations` says why and what to do next.
+- **Offer to join this session before the first send:** if this session hasn't already joined, recommend joining
+  OpenRig in a plain shell so the operator sees a named teammate instead of "unknown sender". Inside tmux, offer
+  joining as optional, with the effects below. Ask the person yes or no after this short explanation:
+  - This adds me as a named member of the team, with my name on messages.
+  - In a plain shell, joining writes no files in your project or personal settings.
+  - Inside tmux on 0.6.11, my sender and reply address is your existing tmux session name, even a number like `0`.
+    `rig attach --self` returns that address and `rig whoami` confirms it; `--display-name` does not change it.
+  - Inside tmux, other agents can type into this window, and stopping the team (`rig down`) also closes this tmux
+    session (both from source, not hand-tested). Transcript recording and, for Claude Code, writing
+    `.openrig/context-collector.cjs` and `.claude/settings.local.json` for the status line were hand-tested on 0.6.11.
+    Updating an existing `.claude/settings.local.json`, keeping its custom status line, is from source.
+  - In a plain shell, other agents reply through the task queue because they can't type into this window, and
+    stopping the team leaves this session running.
+
+  Attach only on their yes; if they decline, continue the operator handoff. For this first contact, use the kernel's
+  rig ID (the `rigId` of the `kernel` row in `rig ps --json`) and its `operator` pod:
+  `rig attach --self --rig <rigId> --pod operator --member person-agent --runtime <claude-code|codex> --print-env`.
+  `--node <logicalId>` binds to an existing seat instead. Attach once, and keep the variables it prints
+  (`OPENRIG_NODE_ID` and `OPENRIG_SESSION_NAME`). Each command may run in a fresh shell, so put them in front of every
+  later `rig` command. Check with `rig whoami --json`.
 - **Give the operator the goal:** ask what they want worked on, in which repository and on which branch, unless they've
   said. Find the `operator.agent` row in `rig ps --nodes --rig kernel --json`, take its `canonicalSessionName`
   (never the logical ID or a guessed name) and send:
@@ -96,15 +123,34 @@ guidance in `AGENTS.md` or `CLAUDE.md` plus the team's skills and plugins. Say s
 - **Check it's ready before you say so:** `rig ps --nodes --rig <rig>`. If an agent is stopped at a prompt or a menu,
   read it with `rig capture <seat>@<rig>` and answer with the key that screen shows (`rig send --help` says how to
   send a digit, a letter or Escape), or ask the person. Capture it again before sending anything more.
-- **Join this session to the team, if that helps:**
-  `rig attach --self --rig <rigId> --pod <pod> --member <name> --runtime <claude-code|codex> --print-env` adds this
-  session as a new member of a pod. `--node <logicalId>` binds it to an existing seat instead. Attach once, and keep
-  the variables it prints (`OPENRIG_NODE_ID` and `OPENRIG_SESSION_NAME`). Each command may run in a fresh shell, so put
-  them in front of every later `rig` command. Check with `rig whoami --json`.
-- **Replies:** other agents can't type into this session. Read work sent to you with
+- **Replies:** in a plain shell, other agents can't type into this session. Read work sent to you with
   `rig queue list --destination <your address>` and `rig queue show <id> --full`, and read an agent's screen with
   `rig capture <seat>@<rig>`.
 
+### Codex: one offer, once, after OpenRig starts
+
+First the agent resolves the person's real Codex folder (`CODEX_HOME`, or `~/.codex` when that isn't set) and puts the exact path in the
+offer, so the person sees the real file, not a placeholder:
+
+> Codex asks you to approve OpenRig commands. May I let six of them run without asking: `rig ps`, `rig capture`, `rig send`,
+> `rig queue`, `rig status` and `rig whoami`, each with whatever follows it? They would run outside Codex's sandbox, in every Codex
+> project and session you run on this computer, and `rig send` and `rig queue` can message your agents and change their task records, not
+> only read them. I'd add one file, `/home/you/.codex/rules/openrig.rules` (the resolved path). Codex reads it when it starts, so it
+> applies from your next Codex session. To undo, ask me to remove the OpenRig rules this added and keep your other rules.
+
+- **No, or no answer:** nothing is written, and Codex behaves as before.
+- **Yes:** the agent applies it the way OpenRig's existing permission steps already describe (`applying-a-permission-policy`, in the
+  installed OpenRig skills): read the existing rules first, keep any stricter rule, change no sandbox or approval setting, and record what
+  it added. The file is created only if it doesn't exist; if it does, the agent changes nothing and says what's there. A new file holds
+  exactly these two lines:
+  ```
+  # Added by OpenRig on the person's yes: these six rig command families run without a prompt. Ask to undo, or delete this file if it holds nothing else.
+  prefix_rule(pattern = ["rig", ["ps", "capture", "send", "queue", "status", "whoami"]], decision = "allow", justification = "OpenRig coordination commands the person approved once")
+  ```
+- **Undo** (the same skill's words: "Undo the OpenRig command allowances added by this setup; keep my other rules"): the agent removes
+  only the lines it recorded adding, keeps anything else in the file, and deletes the file only if it still holds nothing but those lines.
+  It applies from the next Codex session.
+
 ## 3. Follow the work to its result
 
 - **Find the team's task:** the operator gives the goal to the team's lead as a queue task: `dev-build@starter`, or
@@ -118,7 +164,7 @@ guidance in `AGENTS.md` or `CLAUDE.md` plus the team's skills and plugins. Say s
   actually did (the branch, commit, review or PR text), not just that you sent it.
 - **Give the team more work:** write the goal to a file: what to change, in which repository and branch, what done
   looks like, and that the result comes back to you (the branch or commit, the review, any PR text). Then
-  `rig queue create --source <your name> --destination <seat>@<rig> --body-file <file>`, and tell that agent with
+  `rig queue create --source <your name> --destination <seat>@<rig> --summary "<the goal in a sentence>" --body-file <file>`, and tell that agent with
   `rig send <seat>@<rig> "task <id> is yours"`. A message informs, and a queue task is the work someone owns.
   `--source` names you when this session hasn't joined the team.
 - **Then ask what's next.** If no team can take the work, fix that or ask the person. Don't quietly do it yourself.

package/daemon/context-packs/help/manifest.yaml

@@ -1,6 +1,6 @@
 # Agent help: the single troubleshooting and escalation guide (docs/reference/help.md).
 name: help
-version: "0.6.10"
+version: "0.6.12"
 taxonomy: world
 purpose: "What an agent does when its user says OpenRig isn't working: diagnose, fix within permissions, verify, and escalate to OpenRig support."
 files:

package/daemon/context-packs/onboarding-width/manifest.yaml

@@ -1,6 +1,6 @@
 # Public capability and source-map width for the default onboarding walk.
 name: onboarding-width
-version: "0.6.10"
+version: "0.6.12"
 taxonomy: world
 purpose: "The public capability map and source map referenced by the default onboarding walk."
 files: