@openrig/cli 0.6.4-rc.1 → 0.6.5

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

@@ -79,6 +79,30 @@ never silently clipped. Shorten the brief or related detail as directed. Inspect
 the failed row, then deliberately cancel/replace the authored request if its
 content needs correction; a timeout alone is never a reason to replace it.
 
+A follow-up **update** about earlier work ("the change you approved is merged")
+can post into that item's thread with `--reply-to <earlier-qitem-id>`. It is
+accepted only with `--human-intent update`. Name the item whose thread the
+human saw, such as the parked row, and create the update on the same host as
+that item. Send the update from the seat that owns that thread: the seat that
+parked the row, or the author of the earlier item. A human reply in a thread
+reaches its owning seat, so an update from any other seat posts as a new
+message. It also posts as a new message, rather than being refused, if the
+earlier thread is missing or closed, or while the earlier item still waits on
+the human (a pending human decision, or a row parked on the human), since a
+reply in that thread would answer the decision. In every such case the
+`--verify` result says `threaded: false` with the reason.
+
+A **decision** with a few clear choices can carry `--human-questions-file <path>`:
+a JSON array of 1–4 questions, each
+`{"id", "question", "options": [{"id", "label", "recommended"?}]}` with 2–4
+options (labels up to 75 characters, at most one recommended). Slack shows each
+question as a row of buttons. Each click records that answer on the item, and
+the decision resolves once every question has one. You then receive one reply
+row listing the answers, and the item's `humanAnswers` holds the option ids. The
+human may instead type a reply in the thread; that resolves the decision as
+usual, so read the reply rather than assuming an option was picked. Keep the
+brief complete: the questions add buttons, they do not replace the explanation.
+
 If an existing agent-owned row must wait for a **decision**, block it on the **new live qitem ID**
 (`rig queue block <work-id> --on <human-qitem-id> ...`), not on the human address.
 Completion of the human qitem resumes its dependants. Blocking on the human as

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

@@ -64,9 +64,9 @@ These three are a division of labour, not a chain of gates. One agent may hold a
 - **HOW:** a slice carries `intent:` in frontmatter and opens with `## Intent`, `## Mini-requirements`, and `## Proof contract`. A mission carries its intent and mission-level specification in the same authored node file. Keep depth proportional to the work.
 
 ### PROGRESS.md
-- **WHO:** the orchestrator owns `§1` (current state); every agent logs its own outcomes.
+- **WHO:** the orchestrator owns the current state; every agent logs its own outcomes.
 - **WHEN:** on material delivery-state changes and at acceptance.
-- **HOW:** one line per outcome (checkbox), link down for detail; keep frontmatter `stage`/`verified` honest.
+- **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.
 
 ### PROOF.md + proof/
 - **WHO:** the impl/QA pair that worked the slice.

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

@@ -343,6 +343,23 @@ mission carries its intent and mission-level specification in the same authored
 `mission-slice-sop` and any explicit mode overlay; mission specification is not a
 requirement to repeat every slice detail.
 
+### Project knowledge: three kinds, three homes
+
+Before you write down something you learned about a project, decide which kind it is.
+
+- **Product facts** say what is true of the software at a version: commands, behaviour, formats. They live in the
+  product's own documentation, versioned with the code and checked against source. Anywhere else, link to them
+  rather than copying them; a copy stops following releases.
+- **Project judgment** says how to work on the project now: intent, workflow, priorities, routes, who decides what.
+  It lives in the project's world pack and its work tree, and it can change without a release.
+- **Machine-local state** is true of one instance only: paths, hosts, live rosters, counts, credentials. It belongs
+  in configuration, in a seat's `LEARNED.md`, or as the command that derives it. It never goes into shipped content
+  or a shared world.
+
+Agents find a project's declared context with `rig context work-install`, which lists what the project declares:
+its intent, the context files in its `project.yaml` `install` block, and its skills. When project knowledge should
+reach every agent working on the project, add it to that declaration rather than starting a second index.
+
 ### The other axis: AUDIENCE is not MATURITY
 
 These are independent, and merging them is seductive because the merged version is prettier.

package/daemon/assets/plugins/openrig-core/skills/openrig-operating-model/scripts/compose.py

@@ -285,7 +285,7 @@ def resolve_roots():
     out = {}
     out["work_root"] = os.environ.get("OPENRIG_WORKSPACE_ROOT") or rig_config("workspace.root")
 
-    t = os.environ.get("OPENRIG_TOPOLOGY_ROOT") or rig_config("workspace.topology_root")
+    t = os.environ.get("OPENRIG_TOPOLOGY_ROOT") or rig_config("topology.root")
     if not t:
         # Resolve symlinks before walking upward; otherwise a projection ascends
         # its own tree rather than the shared-docs source.
@@ -559,7 +559,7 @@ if __name__ == "__main__":
             if v:
                 print(f"{k}={v}")
             else:
-                key = "workspace.root" if k == "work_root" else "workspace.topology_root"
+                key = "workspace.root" if k == "work_root" else "topology.root"
                 print(f"# {k} UNRESOLVED — set it: rig config set {key} <path>", file=sys.stderr)
         sys.exit(0 if all(r.values()) else 3)
     if not a.name:

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

@@ -120,6 +120,12 @@ and a useful report to the OpenRig team if you are still stuck. If `rig` won't r
 `daemon/docs/reference/help.md` inside the installed `@openrig/cli` package, or https://www.openrig.dev/help/agents
 (the same text).
 
+## Developing OpenRig itself
+
+If you're changing OpenRig's own source in a clone of the openrig repository, use that repository's
+`developing-openrig` skill (in the checkout's `.claude/skills/` or `.agents/skills/`). It maps the architecture, the
+areas where a small change has a large effect, and which tests to run before a pull request.
+
 ## Need more than what ships here?
 
 This index covers the **shipped** surface. Your project, rig or machine may add its own skills and routers. Check the

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

@@ -410,8 +410,23 @@ rig seat clear-attention <session> --reason "operator attested: the operator re-
 rig seat clear-attention <session> --json
 ```
 
-`--reason <text>` is the operator-attestation override path; without it the
-command runs the evidence gate. Either way the action is audited.
+`--reason <text>` can acknowledge startup-status and subset-restore attention.
+It does not bypass full-restore continuity checks or an active pane-identity
+mismatch/missing-pane check; those run first. Successful identity re-verification
+can also clear coexisting startup or subset-restore attention. If neither earlier
+path clears attention, omitting `--reason` requires activity or send evidence.
+Startup and restore clears write their corresponding audit events; an identity-only
+clear updates the current binding and identity verdict without a clear event.
+Acknowledgment or responsiveness alone does not prove that the original
+conversation resumed.
+
+A 422 response names the uncleared class and its failed check. If the recorded
+native token needs correction and you know the actual token, use
+`rig seat set-resume-token <session> --token-stdin --reason <explanation>`, then
+rerun `rig seat clear-attention <session>` to check the live evidence. The token
+update records operator provenance; it does not itself prove continuity.
+Stopping/relaunching a working seat is a separate disruptive operation, not a
+required cleanup or proof of resumed lineage.
 
 ### Periodic snapshots — crash-insurance floor
 
@@ -541,7 +556,7 @@ rig scope mission progress <mission> --add "<line>"   # append a progress line;
 rig scope slice progress <slice-path> --add "<line>"  # same flags: --add / --set, --section <heading>, --status active|done|blocked
 ```
 
-Replaces hand-editing `PROGRESS.md` with markdown. Writes the canonical structure the OpenRig PROGRESS UI page reads. `rig scope mission create` + `rig scope slice create` now scaffold `PROGRESS.md` automatically per `conventions/scope-and-versioning/README.md`.
+Replaces hand-editing `PROGRESS.md` with markdown. Writes the canonical structure the OpenRig PROGRESS UI page reads. `rig scope mission create` + `rig scope slice create` now scaffold `PROGRESS.md` automatically.
 
 ### `rig scope mission|slice stage / verified / repair` — deterministic maturity vocabulary
 
@@ -560,7 +575,7 @@ rig scope slice show <slice>                          # derives read-time effect
                                                       # — stale-`verified` `canonical` reported as effectively `provisional`
 ```
 
-Composes with the `progress` command + 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 `repair`.
+Composes with the `progress` command + scaffolding to update scope IDs and maturity vocabulary through `rig scope`. 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 `repair`.
 
 ### `rig skill audit` — skill cascade provenance
 
@@ -575,7 +590,17 @@ Read-only audit of the skill cascade. Detects `missing` / `stale` / `self-refere
 
 ### `rig seat clear-attention` — extended to derived projection staleness
 
-v0.3.4 shipped `clear-attention` gating on `session.startupStatus` only. v0.4.0 extends the verb to also reach **restoreOutcome-derived** attention (seat is `startupStatus=ready` + `sessionStatus=running` but carries `restoreOutcome=failed` / `continuityOutcome=failed`). Same evidence-gated audit row applies; the `--reason <text>` operator-attestation override carries the runtime / cwd-uncertainty disclosure honestly.
+`clear-attention` also reaches restore-derived attention even when
+`startupStatus=ready` and `sessionStatus=running`. Full-restore attention requires
+the restore reconciler's exact native-token and usable-pane checks; `--reason`
+cannot replace them. Subset-restore attention can reach the attestation path
+when no active pane-identity class takes precedence. That path records
+`operator_recovered` with `runtimeCwdVerified:false`; it is an acknowledgment,
+not proof of resumed lineage. Without an explicit stored continuity outcome,
+inventory leaves continuity null (`unverified` in `rig seat status`) unless the
+same restore attempt has a matching receipt and reconciliation with strict
+native-token and usable-pane proof. Explicit stored outcomes remain historical
+facts; acknowledgment or responsiveness alone cannot infer `resumed`.
 
 ### Native Codex session id capture
 
@@ -877,8 +902,6 @@ narration — a good observation beats ten noisy ones. It's a passing thought yo
 6. Monitor: `rig chatroom wait my-rig --timeout 120`
 7. Close: `rig chatroom topic my-rig "ROUND CLOSED"`
 
-See `docs/planning/roadmaps/chatroom-roundtable-protocol.md` for the full protocol.
-
 ### `rig ask`
 
 ```bash
@@ -918,7 +941,7 @@ rig auth seats … --runtime codex         # seat -> profile registry (metadata
 
 ### `rig context` — the store + compose library (never delivers)
 
-Manage and compose context (any text/markdown) into reusable **packs**. Every piece and pack has a stable, **path-like ref** — you address context the way you address files (`packs/compaction-restore`, `as-built/queue-internals`).
+Manage and compose context (any text/markdown) into reusable **packs**. Every piece and pack has a stable, **path-like ref** — you address context the way you address files (`skills/claude-compaction-restore`, `reference/rig-spec.md`).
 
 ```bash
 rig context list                     # what's in the library
@@ -955,12 +978,12 @@ Walk a seat *through* a pack: each piece is sent into the pane, spaced by `--pac
 - **`--body-context` snapshot rule:** a qitem built from a ref stores the **resolved content** in its body **plus the ref for provenance** — the handoff carries what was actually sent, and a later library edit never silently rewrites a past handoff's history.
 - **The orchestrator habit — assign work *with* its context attached:**
   ```bash
-  rig context compose --out packs/qitem-brief --from as-built/queue.md conventions/c1-proof.md
+  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 "…"
   ```
-  The assignee never greps for the as-built; the curated context rides the durable handoff, survives compaction, and is auditable.
+  Replace `<brief-file>` and `<proof-file>` with your existing local files. The curated context rides the durable handoff, survives compaction, and is auditable.
 
-**Skills tier vs context tier:** skills are the HOT tier (ambient, finite, always-visible front-matter); context packs are the COLD tier (unbounded, fetched on instruction — "walk yourself through `packs/tui-onboarding`"). Don't overrun the skill layer by using skills as context packs — that's what this primitive is for.
+**Skills tier vs context tier:** skills are the HOT tier (ambient, finite, always-visible front-matter); context packs are the COLD tier (unbounded, fetched on instruction — "read `rig context get onboarding-width`"). Don't overrun the skill layer by using skills as context packs — that's what this primitive is for.
 
 ## Lifecycle
 
@@ -1250,6 +1273,7 @@ This lets ordinary agents ask the manager for OpenRig help instead of every agen
 ### Add/remove running topology parts
 
 ```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]
@@ -1258,6 +1282,12 @@ rig shrink <rigId> <podRef> [--json]
 rig unclaim <sessionRef> [--json]
 ```
 
+`rig grow` is the simplest way to add seats: no YAML, the default agent spec, and one
+runtime and working directory for the named seats (`--new-pod` creates a pod for them).
+Check `rig grow --help` on your installed version. Use a fragment with `rig expand` (a pod)
+or `rig add` (one member) when a seat needs an explicit model, a permission policy, a
+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.
@@ -1267,14 +1297,12 @@ Node-granular managed partial restore (v0.3.4+):
 ### Add a member to an existing pod — v0.3.3+
 
 ```bash
-rig add <rig> <member-fragment-path> [--json]
-rig add-member <rig> <member-fragment-path> [--json]
+rig add <rig-id> <pod-namespace> <member-fragment-path> [--json]
 ```
 
-`rig add` (alias `rig add-member`) is the top-level verb for the `add_member`
-converge op. It adds a single member to an existing pod from a YAML/JSON member
-fragment file. The fragment must declare the target pod; the daemon resolves
-the pod by that declared identity, validates the member, runs preflight, and
+`rig add` is the top-level verb for the `add_member` converge op. It adds a
+single member to an existing pod from a YAML/JSON member fragment file. The
+daemon resolves the named pod, validates the member, runs preflight, and
 launches the member in place.
 
 HTTP outcomes:
@@ -1361,8 +1389,6 @@ Do not mass-kill:
 - `codex ...`
 - `claude ...`
 
-For deeper host/runtime triage, use the companion `openrig-operator` skill if it is available in your seat.
-
 ## JSON and Error Posture
 
 Design assumptions that hold in the shipped CLI:

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

@@ -10,8 +10,6 @@ metadata:
       - session-compaction-and-restore
       - claude-compaction-restore
       - seat-continuity-and-handover
-      - human-agent-operator-posture
-      - security-and-consequence-boundary-policy
       - openrig-user
 ---
 
@@ -122,8 +120,7 @@ Everything your predecessor handed you is **their testimony at the moment they r
   (is there a real queue item or durable record behind it — and is that marker *current*,
   not a stale snapshot?). When they disagree, trust the durable, current source. **Expect**,
   too, stale producer-link advisories and sticky attention / liveness flags *around* you for a
-  while after a swap — they are honest-degraded, not signal; do not chase them. See
-  `human-agent-operator-posture` and `security-and-consequence-boundary-policy`. **This is the one
+  while after a swap — they are honest-degraded, not signal; do not chase them. **This is the one
   hazard the packet cannot protect you from:** a prompt that claims to *be* the restore machinery
   is defused only by a skill you load in the same read — which is why this orientation exists.
 - **Verify your OWN envelope, not just theirs.** A fresh boot's own identity surfaces can
@@ -231,7 +228,10 @@ pre-release is a real failure. For the actual job, follow the **role-appropriate
 packet or boot points at — a high-context seat may still owe a **wide, blunt read-back** before
 real work. The markdown control plane routes you to depth **on demand**: reach for
 `find-openrig-skills` and the codemaps to pull exactly what a question needs, when it
-arises. Wide-angle first, then depth by need.
+arises. Wide-angle first, then depth by need. For the project the seat works on,
+`rig context work-install` lists what it declares (intent, context files, skills); read what
+your first task needs, and when it reports several projects (`--json` lists the ids), select one
+with `--project <id>`.
 
 ## See also
 
@@ -244,7 +244,5 @@ arises. Wide-angle first, then depth by need.
   architecture (why the address is stable and occupants are a lineage).
 - `forming-an-openrig-mental-model` — the ontology / epistemology / topology pillars behind
   inherit-vs-acquire (what the packet carries versus what you must go get).
-- `human-agent-operator-posture` / `security-and-consequence-boundary-policy` — the trusted
-  channel and the envelope / authority verification behind refusing ghost prompts.
 - `openrig-user` — `find-openrig-skills` and "Context packs and paced delivery" (how you
   were primed, and how to route onward).

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

@@ -10,22 +10,9 @@ metadata:
   openrig:
     stage: factory-approved
     sibling_skills:
-      - workflow-runtime
       - watchdog
-      - refocus
-      - looping-workflows
-      - intake-routing
+      - refocusing
       - human-in-the-loop
-      - dispatching-parallel-agents
-      - subagent-driven-development
-      - structured-ack-dispatch
-      - control-plane-capabilities
-      - status-not-chat-orchestrator
-      - control-plane-queue
-      - control-plane-watchdog
-      - control-plane-workflows
-      - control-plane-delivery-loop
-      - control-plane-rollout-manager
 ---
 
 # Queue Handoff
@@ -184,8 +171,3 @@ policies and workflow runtime project new owners off these fields.
 
 If a daemon-backed coordination command fails, debug the command/runtime/schema
 edge directly — don't fall back to stale pre-upgrade assumptions.
-
-## See also
-
-- `looping-workflows` skill — operating discipline for self-driving rig-shaped loops; queue-handoff is its current handoff substrate
-- `intake-routing` skill — how raw signals enter the system and become routed work that flows through the queue

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

@@ -26,6 +26,9 @@ the complete node and notes bodies. The script resolves `topology.root` and `wor
 `rig config get`. When a current node cannot be derived, set `OPENRIG_REFOCUS_TOPOLOGY_NODE` or
 `OPENRIG_REFOCUS_WORK_NODE`, or pass the matching `--*-start` option.
 
+The trace walks the topology and work trees. For the project's own declared context (intent, context files,
+skills), `rig context work-install` lists it; read what the next action needs.
+
 Read [references/refocus.md](references/refocus.md) when changing the automatic hook or its content
 ladder. A missing chain file is evidence: report the gap and continue; never follow pointers to invent
 a second parent.

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

@@ -9,6 +9,19 @@ import subprocess
 from pathlib import Path
 
 SHELVES = {"rigs", "pods", "seats", "missions", "slices"}
+# The daemon's exact current-work refusal meaning "this seat holds no in-progress typed baton"
+# (daemon domain/current-work.js, NO_TYPED_IN_PROGRESS). Only this exact text earns the work-root
+# fallback. Compare by equality, not prefix: the sibling refusal "no typed in-progress work
+# resolved to a work node" is a resolution failure and must stay a named gap. If the daemon's
+# wording changes, equality fails toward a named gap that shows the new text, never a silent fallback.
+NO_CURRENT_BATON_BASIS = (
+    "no typed in-progress work (only in-progress rows are considered; a typed row that is "
+    "pending or blocked is not current work)"
+)
+# The daemon's session-name character set and human-class refs (domain/session-name.ts:
+# validateSessionName, isHumanSeatSessionRef).
+SESSION_CHARS = re.compile(r"[A-Za-z0-9\-_.@]+")
+HUMAN_CLASS_SESSION = re.compile(r"human(?:-[A-Za-z0-9._-]+)?@(?:kernel|host)|[A-Za-z0-9._:-]+@external")
 
 
 def rig_output(*args):
@@ -152,8 +165,10 @@ def render_topology(start, root, depth):
     return "\n".join(output)
 
 
-def render_work(start, root, depth):
+def render_work(start, root, depth, fallback=None):
     output = ["## WORK TRACE", f"root: {root}", f"start: {start}"]
+    if fallback:
+        output.append(f"FALLBACK — {fallback}")
     nodes, error = ascent(start, root)
     if error:
         return "\n".join(output + [f"TRACE GAP — {error}"])
@@ -194,10 +209,31 @@ def render_work(start, root, depth):
     return "\n".join(output)
 
 
+def canonical_seat(session):
+    """(member, rig) for a canonical session name, else None so the caller asks `rig whoami`.
+
+    Mirrors the daemon's parse contract (domain/session-name.ts, parseSessionName): the member is
+    everything before the FIRST "@" and the rig is everything after it, which may itself contain
+    "@". Human-class refs are not seats, and a name outside the session character set
+    (validateSessionName) is uncertain, so both keep the lookup."""
+    if not session or not SESSION_CHARS.fullmatch(session) or HUMAN_CLASS_SESSION.fullmatch(session):
+        return None
+    member, at, rig = session.partition("@")
+    return (member, rig) if at and member and rig else None
+
+
 def derive_topology_start(root):
     explicit = os.environ.get("OPENRIG_REFOCUS_TOPOLOGY_NODE")
     if explicit:
         return Path(explicit)
+    # A stale session name (one left over from a seat swap) can name a seat that has no folder;
+    # only an existing seat directory is trusted, otherwise `rig whoami` decides.
+    seat = canonical_seat(os.environ.get("OPENRIG_SESSION_NAME"))
+    if seat:
+        member, rig = seat
+        candidate = root / "rigs" / rig / "seats" / member
+        if candidate.is_dir():
+            return candidate
     raw = rig_output("whoami", "--json")
     if not raw:
         return None
@@ -235,6 +271,8 @@ def main():
     parser.add_argument("--depth", choices=("light", "full"), default=os.environ.get("OPENRIG_REFOCUS_DEPTH", "light"))
     parser.add_argument("--topology-start")
     parser.add_argument("--work-start")
+    parser.add_argument("--work-basis", help="the daemon's reason no current work node was named")
+    parser.add_argument("--work-unknown", help="why the current work node could not be read")
     args = parser.parse_args()
 
     sections = []
@@ -252,9 +290,23 @@ def main():
         if root is None:
             sections.append("## WORK TRACE\nTRACE GAP — workspace.root is unresolved")
         else:
-            start = Path(args.work_start) if args.work_start else derive_work_start(root)
-            sections.append(render_work(start, root, args.depth) if start else
-                            "## WORK TRACE\nTRACE GAP — current work node is unresolved; set OPENRIG_REFOCUS_WORK_NODE")
+            # Precedence: an explicit start wins; then the hook's daemon answer (basis or unknown);
+            # only a standalone run with neither falls back to inferring from the working directory.
+            explicit = args.work_start or os.environ.get("OPENRIG_REFOCUS_WORK_NODE")
+            if explicit:
+                sections.append(render_work(Path(explicit), root, args.depth))
+            elif args.work_basis == NO_CURRENT_BATON_BASIS:
+                sections.append(render_work(root, root, args.depth, fallback=(
+                    f"no current typed baton ({args.work_basis}). Showing the project-level chain from the work root: "
+                    "a broad orientation, not evidence of a current mission")))
+            elif args.work_basis:
+                sections.append(f"## WORK TRACE\nTRACE GAP — no single current work node: {args.work_basis}")
+            elif args.work_unknown:
+                sections.append(f"## WORK TRACE\nTRACE GAP — current work node UNKNOWN: {args.work_unknown}")
+            else:
+                start = derive_work_start(root)
+                sections.append(render_work(start, root, args.depth) if start else
+                                "## WORK TRACE\nTRACE GAP — current work node is unresolved; set OPENRIG_REFOCUS_WORK_NODE")
 
     print("\n\n".join(sections))
     return 0

package/daemon/assets/plugins/openrig-core/skills/seat-continuity-and-handover/SKILL.md

@@ -6,16 +6,11 @@ metadata:
     stage: factory-approved
     sibling_skills:
       - claude-compaction-restore
-      - mental-model-ha
-      - scope-recovery
       - session-compaction-and-restore
       - retiring-and-inheriting-a-seat
       - agent-startup-and-context-ingestion
       - agent-starters
-      - composable-priming-packs
       - session-source-fork
-      - claude-compact-in-place
-      - pre-maintenance-agent-preservation
 ---
 
 # Seat Continuity and Handover

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

@@ -8,16 +8,11 @@ metadata:
     stage: factory-approved
     sibling_skills:
       - claude-compaction-restore
-      - mental-model-ha
-      - scope-recovery
       - agent-startup-and-context-ingestion
       - agent-starters
-      - composable-priming-packs
       - session-source-fork
       - seat-continuity-and-handover
       - retiring-and-inheriting-a-seat
-      - claude-compact-in-place
-      - pre-maintenance-agent-preservation
 ---
 
 # Session Compaction and Restore
@@ -108,6 +103,11 @@ stay durable-substrate-first (the packet/artifacts are the truth; the CLI is the
 3. **A runtime resume is mistaken for a seat handover or fork.** These have different continuity outcomes and provenance — don't conflate.
 4. **A rebuilt seat starts with stale instructions that conflict with current workflow mode.** Restore must include current state, not just historical state.
 
+**Re-entering project context, on any runtime.** A restore packet carries the work in flight, not the project's
+declared intent and context files. `rig context work-install` lists what the project declares; read the pieces the
+restored task needs. `--deliver` prints them all, and when several projects are declared (`--json` lists the
+ids), select one with `--project <id>` instead of guessing.
+
 ## Proof standard
 
 Proof should include a deliberate compaction/restart of a seat with
@@ -155,7 +155,6 @@ restoration; measure the resumed seat against the proof standard above.
 ## See also
 
 - `claude-compaction-restore` skill — the Claude Code restore SOP (PreCompact hook + JSONL restore script for post-compaction recovery)
-- `mental-model-ha` skill — HA-pair compaction recovery (different scenario; sister primitive)
 - `session-source-fork` skill — `fork` mode for native-runtime-continuity-based restoration
 - `seat-continuity-and-handover` skill — occupant-creation primitives (resume/fork/rebuild/fresh) that this primitive instantiates
 - `openrig-operating-model` skill — placement and authority of durable context

package/daemon/context-packs/help/help.md

@@ -78,12 +78,17 @@ involved before proposing changes.
 Compare the harness version and what you actually observe before attributing a failure to one of these. Check the
 issue's current status; a similar symptom alone is not a diagnosis.
 
-- Claude seats reported as needing attention after a restore: [#86](https://github.com/mvschwarz/openrig/issues/86).
-- Claude usage limits are not detected: [#98](https://github.com/mvschwarz/openrig/issues/98),
-  [#99](https://github.com/mvschwarz/openrig/issues/99).
-- Codex prompt variants not recognised as ready: [#79](https://github.com/mvschwarz/openrig/issues/79).
+- Claude seats reported as needing attention after a restore: [#86](https://github.com/mvschwarz/openrig/issues/86),
+  [#273](https://github.com/mvschwarz/openrig/issues/273).
+- Claude usage limits may not be detected: [#99](https://github.com/mvschwarz/openrig/issues/99).
+- Codex prompt variants not recognised as idle: [#79](https://github.com/mvschwarz/openrig/issues/79).
 - Codex asks about hook trust at first launch: [#17](https://github.com/mvschwarz/openrig/issues/17), not reproduced
   by the team.
+- A Codex seat on the default `workspace-write` sandbox starts without network access, so it can't reach the local
+  daemon, when its Codex configuration sets network access off, a managed requirement could restrict it, or Codex
+  doesn't answer OpenRig's configuration read in time: [#275](https://github.com/mvschwarz/openrig/issues/275).
+- Stopping the daemon can report a timeout while closing connections:
+  [#166](https://github.com/mvschwarz/openrig/issues/166).
 
 For everything else, search [open issues](https://github.com/mvschwarz/openrig/issues).
 

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.4-rc.1"
+version: "0.6.5"
 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.4-rc.1"
+version: "0.6.5"
 taxonomy: world
 purpose: "The public capability map and source map referenced by the default onboarding walk."
 files:

package/daemon/context-packs/onboarding-width/public-what-you-can-do.md

@@ -40,7 +40,8 @@ one command away. Your memory of the fleet is a claim about the past.
 - **`rig view list` / `rig view show <lens>`** — named lenses over coordination state: use
   `view show escalations` for owner attention, `view show pickup` for claimed-row state, and
   `view show execution` for done/now/next and current authored planning guidance with its
-  source. Mission and wave inspection shows admission and exit guidance; wave/slice details
+  source (`--project <name> --mission <id>` reads a mission in another catalogued project, not
+  only the default workspace). Mission and wave inspection shows admission and exit guidance; wave/slice details
   include review decisions. Accepted-core guidance stays separate from full-contract proof,
   live custody and executable dependencies. An `INDETERMINATE` cell stays unknown rather than
   being filled from memory. **`rig view register`** turns a query you keep re-running into a
@@ -239,10 +240,11 @@ relay is a reason to inspect the available routing, not to surrender judgment to
 
 ## Bringing things into and out of existence
 
-**For a first useful repository change**, preview `first-project`, inspect
-`rig up first-project --cwd . --plan`, and follow `docs/reference/getting-started.md`.
-Its native Codex owner/checker team is the focused starting point; verify prerequisites and
-actual runtime readiness before work. Existing Herdr/cmux terminals can present the managed team
+**For a first useful repository change**, pick the first-project recipe that matches the
+accounts you have: `first-project` (two Codex seats), `first-project-claude` (two Claude Code
+seats) or `first-project-mixed` (a Claude Code owner and a Codex checker). Preview it, inspect
+`rig up <recipe> --cwd . --plan`, and follow `docs/reference/getting-started.md`. Each is the same
+owner/checker team; verify prerequisites and actual runtime readiness before work. Existing Herdr/cmux terminals can present the managed team
 through `rig terminal open`.
 
 **Need a small team now, without authoring YAML?** Start with `rig create`, then use `rig grow`
@@ -354,6 +356,14 @@ version, from checking the environment to a useful report to the OpenRig team.
   Effective-model detection follows the identity-verified current occupant, not a retained
   predecessor; a `<synthetic>` transcript record is skipped, so a PENDING model check is not a
   divergence.
+- **`rig seat set-permissions <seat> --mode <mode> --reason <text>`** — select one seat's native
+  permission mode for its future managed launches; it relaunches nothing, and `inherit` clears the
+  selection. `rig seat status` reports the selection, but a status read does not prove the
+  running process enforces it.
+- **`rig seat set-typing-guard <seat> --enabled true|false --reason <text>`** — protect a human's
+  draft in that seat: automatic input is retained instead of typed while the guard is on.
+  **`rig seat held-messages`** lists what was retained and **`rig seat retire-held-message`**
+  retires one; disabling the guard does not replay held messages.
 - **`rig compact-plan`** → **`rig compact`** — who is near the context wall, then act on it.
   **Ordering matters: running `compact` without the plan is guessing which seat needed it.**
 - **Know what compaction costs before you reach for it.** On some runtimes what comes back has
@@ -481,7 +491,8 @@ working arrangement becomes something someone else can instantiate.
 - **`rig spec validate` → `preflight` → `audit`** — three different questions, in order: is the
   file well-formed, would it boot *on this host*, and **will the agents it launches actually know
   anything when they arrive**. The third is the one people skip. Unknown structural keys refuse
-  with their path instead of being normalized away.
+  with their path instead of being normalized away. Use `rig spec validate --help` for its current
+  behavior and options.
 - **`rig context trace --pod <pod>`** — walk the context chain through instance → rig → pod → seat
   when the pod altitude matters.
 - **`rig specs show` / `preview` / `add` / `sync` / `rename` / `remove`** — where a spec lives,
@@ -547,9 +558,10 @@ your circumstances is configuration, and the ones that are not, another agent ca
   and put it back exactly as it was, or additively lay down the canonical project scaffold on a
   box that has none. Instance startup uses the same additive initializer for the surrounding
   `state`, `context`, `skills`, `topology`, and operational roots.
-- **`rig policy list` / `show` / `current`** *(v0.5.2)* — what permission policy is actually in
-  effect: discovers custom policy specs, validates refs (malformed can never read as valid OR
-  absent), shows what would apply.
+- **`rig policy permissions list` / `show` / `current` / `apply`** — what permission policy is
+  actually in effect: discovers custom policy specs, validates refs (malformed can never read as
+  valid OR absent), shows what would apply. The older `rig policy list|show|current|apply` forms
+  remain as aliases with the same output.
 - **`rig policy cite` / `defaults`** — what posture the operator is in: how autonomous to be, how
   loudly to report, whether to batch permission questions or block on them. **This declares a
   posture; it does not grant or deny permissions** — the harness's own settings are the control
@@ -606,9 +618,10 @@ your circumstances is configuration, and the ones that are not, another agent ca
   services and human routes. Dated verification does not prove delivery. `timezone` gives
   persistent local-time guidance.
   **?** opens full-screen Help with command grammar and examples; Escape returns to the caller.
-  **`rig tui commands`** lists everything it can do without launching it. **`rig ui open`** is
-  unmaintained, best-effort, and replaced by the TUI, so never diagnose product behaviour from
-  the web UI. The TUI plus Slack are the human surface; the CLI plus terminal are the agent surface.
+  **`rig tui commands`** lists everything it can do without launching it. The web UI is off by
+  default; `rig config set ui.enabled true` plus a daemon stop and start turns it on. **`rig ui
+  open`** is unmaintained, best-effort, and replaced by the TUI, so never diagnose product
+  behaviour from the web UI. The TUI plus Slack are the human surface; the CLI plus terminal are the agent surface.
 - **`rig mcp serve`** — how an agent that speaks MCP rather than shell drives OpenRig, and which
   operations are exposed that way. Relevant the moment a tool you are integrating cannot run a
   shell command.

package/daemon/context-packs/reference/getting-started.md

@@ -15,8 +15,13 @@ supported; Node 26 and other versions are untested.
 Codex's `-s workspace-write`, with approval policy from your native configuration,
 or Claude Code's `acceptEdits`, which still leaves commands subject to native
 rules and prompts. Codex's sandbox normally blocks network access, including the
-local OpenRig daemon. A command allowance does not change general sandbox/network
-settings. The starter's `profile: default` selects OpenRig resources, not a native
+local OpenRig daemon, so before that plain launch OpenRig asks Codex for its own
+configuration and adds network access inside the sandbox unless a configuration
+layer sets `sandbox_workspace_write.network_access` or a managed requirement could
+restrict it. To keep it off, set `network_access = false` under
+`[sandbox_workspace_write]` in your Codex configuration. If Codex does not answer
+within a few seconds, the seat starts without it. A command allowance does not
+change general sandbox/network settings. The starter's `profile: default` selects OpenRig resources, not a native
 permission profile.
 Agent-guided setup [asks once](#have-your-agent-configure-permissions): “Allow
 your agents to run OpenRig commands without repeated permission prompts?”