@openrig/cli 0.6.4 → 0.6.6

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

@@ -13,7 +13,7 @@ You're running inside OpenRig. OpenRig ships a set of **skills** — small docum
 
 ## How OpenRig context works (30 seconds)
 
-Skills are **progressive disclosure**: a skill's *name + description* sit in your context ambiently (the "hot tier"); its *body* loads only when you open it. So you don't pre-read everything — you pattern-match a skill's "when" to your moment, then open just that one. This file is the index over the whole shipped set. (For bounded procedures, open `agent-operated-workflows`; for ongoing agent-backed applications, open `agent-operated-software`.)
+Skills are **progressive disclosure**: a skill's *name + description* sit in your context ambiently (the "hot tier"); its *body* loads only when you open it. So you don't pre-read everything — you pattern-match a skill's "when" to your moment, then open just that one. This file recommends skills from the shipped set. (For bounded procedures, open `agent-operated-workflows`; for ongoing agent-backed applications, open `agent-operated-software`.)
 
 Every row below names **how to reach the skill** — already-hot, or an exact load path. No row is a dead end.
 
@@ -43,7 +43,7 @@ shows an operator — `get` is the agent-facing pull.)
 
 ## The index
 
-> Membership rule (`layout.skills[*].edges.length > 0`): every public skill with at least one product edge in the generated edge layout appears exactly once in this index; no other skill appears.
+> Membership rule (`layout.skills[*].edges.length > 0`): this index recommends skills from the public product edges. Optional procedures remain available through `rig context list` without a recommendation here.
 
 ### Always loaded — the universal spine (open its body when its moment hits)
 These are auto-delivered to every rig; their name+description are already in your context. Open the body when the "when" matches.
@@ -72,7 +72,7 @@ These are auto-delivered to every rig; their name+description are already in you
 These ship in the OpenRig repo and reach a seat when its profile selects them. To use one, select it in your profile's `uses.skills`, or open it directly at `packages/daemon/specs/agents/shared/skills/core/<skill>/SKILL.md`.
 
 - **openrig-software-factory** — a user wants continuing reviewed work: manual/team, queue-only orchestration or an explicit Workflow; add one or two seats to the running starter when useful, with context, ownership, concurrency, spend and permission limits. Load `rig context get skills/core/openrig-software-factory/SKILL.md`.
-- **openrig-architect** — authoring a rig or topology (NOT for changing OpenRig itself — that's `openrig-builder`).
+- **openrig-architect** — authoring a rig or topology (NOT for changing OpenRig itself — that's `developing-openrig`).
 - **openrig-cmux** — driving the `cmux` terminal provider.
 - **openrig-herdr** — opening/managing seat terminals via the default proof-gated provider.
 - **agent-startup-and-context-ingestion** — a seat is booting and ingesting its startup context.
@@ -106,7 +106,6 @@ Product-management craft (load when shaping/reviewing work):
 ### Vendored craft — load when you're coding (ships with upstream provenance)
 General engineering skills OpenRig ships as vendored copies. Open when the task matches; they carry "modified by OpenRig" provenance.
 
-- **test-driven-development** — implementing a feature or bugfix: write the failing test first.
 - **verification-before-completion** — about to claim done / passing / fixed: run the check and read the output first.
 - **systematic-debugging** — debugging: find the root cause before the fix.
 - **agent-browser** — driving a browser (screenshot / screencast) from an agent.
@@ -120,6 +119,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

@@ -301,7 +301,10 @@ OpenRig v0.3.0 adds `rig agent-image`, `rig context-pack`, `rig workspace`, and
 `rig config init-workspace`. *(0.5.0: the `rig context-pack` alias is retired — the store + compose library is the single `rig context` noun; see "Context packs and paced delivery (0.5.0)".)* It also shifts fresh-user starter guidance toward
 `product-team` for human-directed work and `conveyor` for workflow-oriented
 work. Treat `demo` as legacy/test content unless a task specifically asks for
-the old demo spec.
+the old demo spec. *(0.6.6: the built-in teams are `starter` and `factory`, plus the
+specialist teams `code-review`, `research` and `pm`. `product-team`, `conveyor` and
+`demo` are gone, and `first-project` is starter's old name. `workshop` is a rig
+bundle.)*
 
 OpenRig v0.3.1 adds public package/source surfaces for Plugin Primitive v0,
 Claude Auto-Compaction Policy, migration `040_workflow_specs_diagnostic`,
@@ -327,7 +330,9 @@ before relying on a policy or its default.
 
 Compatibility checks:
 - `rig down` accepts a rig name or id. An ambiguous name matching more than one
-  active rig is refused with matching ids; use the intended id.
+  active rig is refused with matching ids; use the intended id. It ends every
+  agent's session and any work in progress, so check `rig ps --nodes --rig <rig>`
+  and that the person asked; `rig up <rig> --existing` restores it.
 - For queue/view JSON or limit differences, compare the installed command's help,
   the running daemon version and the actual response. A wrapper mismatch is not
   by itself a daemon-health failure, and historical workarounds are not current
@@ -357,8 +362,8 @@ rig start --json             # JSON output for agents
 ```
 
 Framing: `rig start` is the RECOVERY entry point, not the getting-started
-hero. The fresh-user boot hero remains `rig up <starter>` (typically
-`rig up product-team`). Reach for `rig start` after a host reboot, daemon
+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
 restart, or any "bring my rigs back" moment.
 
 ### `rig reconcile-session` — no-launch adopt of a hand-resumed session
@@ -410,8 +415,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 +561,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 +580,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 +595,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 +907,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 +946,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 +983,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 +1278,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 +1287,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 +1302,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 +1394,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