@openrig/cli 0.5.5 → 0.5.6

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

@@ -92,17 +92,10 @@ def field_of(payload, field):
     return (" ".join(str(v).split()) if v is not None else None), None
 
 def _cut_at_boundary(s, n):
-    """Cut to AT MOST n chars, NEVER inside a token.
+    """Cut to at most n characters without splitting a token.
 
-    Measured 2026-08-14: a cold subject read `see PROOF.m…` and `see P…` in the walk's own
-    output. A path cut mid-token still READS as a path — the reader cannot tell `PROOF.m` from
-    a file that is actually called that, so a truncation artifact is silently promoted to a
-    fact about the tree. Filenames, paths and identifiers are exactly the tokens a reader is
-    most likely to act on, which makes them the worst place to lose characters.
-
-    So the cut lands on whitespace or it does not land: paragraph, then line, then word. A
-    single unbroken token longer than the budget is DROPPED WHOLE rather than shortened —
-    half an identifier is worse than no identifier."""
+    Prefer paragraph, line, then word boundaries. Drop a single unbroken token
+    that exceeds the budget; a partial path or identifier looks valid but is not."""
     if len(s) <= n:
         return s
     head = s[:n]
@@ -146,27 +139,11 @@ def dep_artifacts(dep_dir, names, dep_fm):
 
 
 def blocking_state(payload, lvl, names):
-    """THE LEAF'S NEXT-ACTION FACTS, composed BESIDE its intent. Returns a line or None.
-
-    Measured 2026-08-14: a cold seat walked `--field intent`, reconstructed the mission's
-    thesis from ~90 words, and finished green and ready to start work its own slice says is
-    blocked — because the walk opened the file holding `status: not-started`, extracted
-    exactly one key, and threw the rest away. It answers *what is this for* completely and
-    *what should I do now* not at all, and ships as though the first answered the second.
-
-    So the blocking facts ride along: `status`, and `depends:` — a sibling slice id (or a
-    list of them) RESOLVED ON DISK so the dependency's current state is reported rather than
-    remembered. Leaf only — the ancestors say what the work is for, and only the leaf says
-    whether to start it.
-
-    Measured 2026-08-14: a cold subject working slice 13 needed slice 11's OUTPUT. The walk
-    gave it 11's STATE and nothing else; the subject called the missing location "the single
-    largest unknown in my Phase 1 answer and it was the load-bearing input", and resolved it
-    with `ls` a phase later. A status answers *may I start*; it does not answer *where is the
-    thing I start from*. So each dependency now renders its ABSOLUTE PATH and its output
-    ARTIFACTS beside its state — and an id that resolves to nothing renders UNRESOLVED, said
-    out loud, because an unresolvable dependency dropped in silence is the same false
-    confidence in a smaller box."""
+    """Return leaf status and dependency facts beside its intent, or None.
+
+    Intent alone does not say whether work may start or where dependency outputs
+    live. Resolve dependencies on disk and report state, absolute path, and
+    artifacts; leave ancestors to carry purpose."""
     fm, _ = frontmatter(payload)
     if not fm:
         return None
@@ -208,18 +185,10 @@ def blocking_state(payload, lvl, names):
 
 
 def operates_on(payload):
-    """The roots this WORK touches — which are NOT the root the trace ascended.
-
-    Measured 2026-08-14, 4 cold subjects out of 4: the walk orients to PURPOSE excellently
-    and misleads on LOCATION every time. Naming the walked root did not help, because the
-    failure is not "which tree am I looking at" — it is "which tree does this work act on."
-    A slice about the skill library renders inside a map rooted at the workspace, and the
-    reader plans into the tree it was shown. One subject planned to CREATE a second corpus,
-    duplicating the very thing whose duplication was that slice's subject.
-
-    The walk cannot infer this: a work node is not bound to a root. So the node DECLARES it
-    and the leaf renders it verbatim. Mechanical, like `depends:`, and absent when unstated
-    rather than guessed."""
+    """Return the roots a work node declares it operates on.
+
+    The tree being walked need not be the tree the work changes. This cannot be
+    inferred safely, so render `operates_on` verbatim and omit it when unstated."""
     fm, _ = frontmatter(payload)
     if not fm:
         return None
@@ -229,17 +198,9 @@ def operates_on(payload):
     return [" ".join(str(r).split()) for r in (roots if isinstance(roots, list) else [roots])]
 
 
-# WHAT SURVIVES TRUNCATION. Both lists are read off the 15 real SPEC.md files of
-# context-engineering-v2 — every pattern below matches a heading that actually exists there;
-# no category is invented for symmetry. CONTRACT is the completion-and-scope family (`Done
-# when`, `What done looks like`, `Scope fences`, `Output`, `Inputs`, `Depends on`, `What must
-# be built`, `How we will know it works`, `PAYLOAD`). DISCUSSION is the rationale-and-history
-# family (`Why …`, `The problem …`, `The evidence …`, `The finding …`, `RESULT …`, `Also
-# found`, `Triage`, `What is already done`, `New evidence`, `Where this spec was wrong`) —
-# valuable, and the first thing a reader can go get from the file itself.
-# Anything unmatched sits in the MIDDLE on purpose: an unfamiliar heading is neither
-# privileged nor sacrificed, so a new section shape degrades gracefully instead of silently
-# becoming the first casualty.
+# Preserve contract and scope sections ahead of rationale and history when the
+# leaf body exceeds its cap. Unknown headings remain middle priority so new shapes
+# degrade without being silently privileged or discarded.
 _PRI_CONTRACT = re.compile(
     r"(done when|what done looks like|scope fence|outputs?\b|inputs?\b|depends on|"
     r"what must be built|how we will know|acceptance|payload|deliverable)", re.I)
@@ -278,24 +239,11 @@ def _sections(body):
 
 
 def leaf_body(payload, cap):
-    """Ancestors compose by FIELD; the leaf composes by BODY.
-
-    Measured 2026-08-14 (slice 01 A/B): a cold agent given three intent sentences
-    reconstructed the mission's thesis correctly, then assumed the work tree it had been
-    shown was the tree its slice was about. The slice was about the TOPOLOGY tree. It built
-    a coherent four-step plan aimed at the wrong one — and the three altitudes it planned
-    over need three different verbs, which it had no way to know.
-
-    That is misdirection, not a gap. Ancestors compress beautifully because they are stable
-    and abstract. **The leaf is where the nouns live, and a field-only walk throws them
-    away** — every word that would have disambiguated it sat in the body that was not shown.
-
-    Truncation is BY PRIORITY, never by position. Measured 2026-08-14: positional cutting on
-    slice 13 dropped `Output`, `Done when` and `Scope fences` — the three sections that say
-    what to produce, when it is finished and what it may not touch — and kept four screens of
-    rationale, because the rationale happened to be written first. The subject rated its own
-    grasp of purpose 85% and its next action 70% and named that omission as the reason. A
-    render that keeps the argument and drops the contract has the priorities backwards."""
+    """Render the leaf body, truncating by semantic priority rather than position.
+
+    Ancestors can compose by stable intent fields, but the leaf carries the nouns,
+    boundaries, outputs, and completion conditions. When over budget, retain
+    contract and scope sections before explanatory history."""
     if not payload:
         return None
     m = re.match(r"^---\n.*?\n---\n", payload, re.S)
@@ -309,13 +257,8 @@ def leaf_body(payload, cap):
         kept = _cut_at_boundary(body, cap)
         return (kept + "\n\n[… " + str(len(body) - len(kept)) + " more chars, no further "
                 "headings — prose tail]" + "\n(read the node file for these)")
-    # Drop LOWEST priority first and, within a tier, the LARGEST section first. Size beats
-    # position here and it was measured: slice 13's contract sections total more than any
-    # sane cap, and dropping the tier tail-first killed `Done when` (12 lines) and `Scope
-    # fences` (9) to save `Output` and `Inputs` (~2k chars each) — the two long prose
-    # sections eating the two short decisive ones. Largest-first keeps the most sections
-    # standing, and in these specs the short section is the one carrying the ruling. The
-    # preamble (title + lede, index 0) is never a candidate: it is what names the thing.
+    # Drop the lowest-priority, largest sections first to preserve more short,
+    # decisive sections. The title and lede preamble are never candidates.
     keep, size = set(range(len(secs))), len(body)
     for i in sorted(range(1, len(secs)), key=lambda i: (-_priority(secs[i][0]), -len(secs[i][1]))):
         if size <= cap:
@@ -326,11 +269,7 @@ def leaf_body(payload, cap):
     if len(kept) > cap:                    # preamble alone overflows; cut it safely, never mid-token
         kept = _cut_at_boundary(kept, cap)
     dropped = [secs[i][0] for i in range(1, len(secs)) if i not in keep]
-    # NAME what was cut. A byte count reads as trivia; two subjects in a row lost the
-    # acceptance criteria to it and neither could tell, because a truncated head can end on
-    # a clean rhetorical close and look like a finished document. Listing the dropped
-    # headings turns invisible truncation into a decision the reader can actually make —
-    # one subject lowered its own confidence honestly on the strength of this line alone.
+    # Name omitted headings so truncation is visible to the reader.
     tail = ("\n\nOMITTED FROM THIS RENDER — " + str(len(body) - len(kept)) + " chars, sections: "
             + " · ".join(dropped) if dropped else
             "\n\n[… " + str(len(body) - len(kept)) + " more chars, no further headings — prose tail]")
@@ -338,29 +277,18 @@ def leaf_body(payload, cap):
 
 
 def resolve_roots():
-    """WHERE THE TWO TREES LIVE — resolved, never hardcoded, never guessed.
-
-    A skill ships inside a plugin and its scripts must run unmodified on a stranger's machine.
-    The WORK tree has been addressable for a while (`workspace.root`). The TOPOLOGY tree was not:
-    every consumer hardcoded `~/.openrig/shared-docs`, so half the walk was portable and half was
-    not. Precedence matches every other typed key: env > config > derived > fail-with-the-key.
-
-    The derived step is honest rather than clever: this script physically lives inside the
-    shared-docs tree, so it can find its own `rigs/` sibling by walking up from __file__. That
-    works for the library copy and its symlinked projections (resolved with realpath) and NOT for
-    a real plugin copy — which is correct. A plugin copy on
-    someone else's machine has no business inferring a path; it must be told, and it fails saying
-    exactly which key to set rather than picking a directory and being confidently wrong."""
+    """Resolve work and topology roots from configuration or explicit environment.
+
+    A library copy may derive topology from its own real path; a projected plugin
+    copy must be configured rather than guessing. Resolution follows environment,
+    configuration, then derived location."""
     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")
     if not t:
-        # realpath, NOT abspath: the runtime tiers project this script as a SYMLINK
-        # (~/.claude/skills/... -> the library copy). abspath keeps the symlink's own path, so
-        # the ascent runs up a tree with no `rigs/` sibling and topology_root comes back
-        # UNRESOLVED — for every agent reaching the tool the documented way. Measured 2026-08-14:
-        # exit 3 via the projection, exit 0 via the realpath, same file.
+        # Resolve symlinks before walking upward; otherwise a projection ascends
+        # its own tree rather than the shared-docs source.
         here = os.path.realpath(__file__)
         for _ in range(6):                       # scripts/ skill/ skills/ skill-canon/ -> shared-docs/
             here = os.path.dirname(here)
@@ -406,11 +334,8 @@ def compose_up(start, names, root, field=None, prefer=False, shelves=None, leaf_
     # (first match wins) instead of N independent chains. A tree mid-rename is the normal
     # case, not an exception: SPEC.md is the current node filename and README.md the legacy
     # one, and a trace that cannot span both reports a chain as broken when it is merely mixed.
-    # Test the START NODE against the TREES, not the root against the workspace. Being
-    # somewhere under workspace.root is not the property that matters: the measured hazard
-    # is a fixture tree at workspace/artifacts/<qitem>/fixture-workspace/missions/, which is
-    # inside workspace.root and is not a work tree. Only slices_root and topology_root name
-    # actual trees, so those are the discriminator.
+    # Validate the start node against configured tree roots. Merely sitting below
+    # workspace.root is insufficient because fixtures may look structurally valid.
     _cfg = [c for c in (rig_config("workspace.slices_root"),
                         resolve_roots().get("topology_root")) if c]
     _here = os.path.abspath(start)
@@ -465,17 +390,11 @@ def compose_up(start, names, root, field=None, prefer=False, shelves=None, leaf_
             rungs.append((label, row)); pending = []
         leads = [("" if i == 0 else "   " * (i - 1) + "└─ ") + rungs[i][0] + "/" for i in range(len(rungs))]
         width = max(len(l) for l in leads) + 2
-        # NAME THE REFERENT. Three cold subjects in a row assumed the tree they were
-        # SHOWN was the tree their slice was ABOUT, and planned into the wrong one. The map
-        # cannot know "work" vs "topology" semantically, but it knows what it walked — and
-        # root + chain filename is enough to tell them apart (workspace/SPEC.md vs rigs/LEARNED.md).
+        # Name the walked root and chain so readers do not confuse the tree being
+        # shown with the tree the work will change.
         out.append(f"\nTRACE · root {levels[0]} · chain {' → '.join(group)}")
-        # VALIDATE THE ROOT. Measured 2026-08-14: this box has four directories named
-        # `missions`, one of them a TEST FIXTURE under artifacts/. Handed the fixture as
-        # --root, the trace renders an equally clean, equally confident chain — because
-        # `✓ seeded` means "a file was found here", never "you are in the right tree".
-        # Confidence that is independent of correctness is the failure this whole mission
-        # is against, so the trace now says when it cannot vouch for where it is standing.
+        # Warn on an unconfigured root: an arbitrary lookalike tree can render a
+        # clean chain.
         if _root_warning:
             out.append(_root_warning)
         for i, (_label, (lvl, where, state, payload, fval, fnote)) in enumerate(rungs):

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

@@ -34,24 +34,30 @@ Don't guess a file path or a name. Go **ask → ref → load** in three steps:
 rig context get skills/core/rig-lifecycle
 ```
 
+The router itself is available through both forms it teaches:
+`rig context get openrig-skills` and `rig context get skills/core/openrig-skills`.
+
 The content is served **from the installed CLI**, so what you load always matches your running version —
 no path-guessing, no frozen-fork drift. (The daemon assembles the same bundle `rig context preview`
 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.
+
 ### 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.
 
 - **forming-an-openrig-mental-model** — first boot, or you're unsure how the pieces fit. The runtime mental model.
 - **openrig-operating-model** — you do not know where context or work belongs, or you are about to duplicate knowledge. The two-tree placement and trace-to-root model.
 - **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.
 - **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.
 - **refocusing** — a long-running seat may have lost the product outcome, crossed a major boundary, or compacted and needs a fresh path-based trace.
 - **seat-continuity-and-handover** — handing your seat's work across a restart or to another owner.
-<!-- Territory amended 2026-08-26 by desk ruling qitem-20260826080800-r054-s9a-scope-ruling. -->
 - **orienting-to-an-inherited-seat** — you just inherited an existing seat through a planned handover and need to verify its identity, state, and testimony.
 - **retiring-and-inheriting-a-seat** — you're planning a seat transition and need to retire the current occupant into a fresh successor without losing continuity.
 - **mission-slice-sop** — you're working a mission/slice (the SDLC: intent → mini-requirements + proof contract → build → QA → proof). The operating manual.
@@ -68,22 +74,21 @@ These ship in the OpenRig repo and reach a seat when its profile selects them. T
 - **agent-startup-and-context-ingestion** — a seat is booting and ingesting its startup context.
 - **topology-mutation-and-seat-management** — adding, removing, renaming seats or otherwise mutating rig topology.
 - **rig-lifecycle** — rig up / down / pause / resume lifecycle operations.
-- **applying-a-permission-policy** — a rig/seat has a permission policy attached, or you're setting one up (Locked / Standard / Open): translate it into the live harness config (Claude `settings.json` / Codex `config.toml`), agent-driven + interactive. Reached at onboarding and at rig setup/preflight. (YOLO / bypass is a launch-flag OpenRig sets, not this skill.)
 - **rig-bundles-and-shareable-artifacts** — packaging or installing a rig bundle / shareable artifact.
 - **cross-host-rig-commands** — reaching seats or queues on another host (`--host`).
 - **openrig-upgrade** — upgrading OpenRig or the daemon.
 - **agent-starters** — composing an agent's starter context / priming packs.
 - **specification-system** — authoring or reading AgentSpecs and rig specs.
-- **attention-queue** — managing the attention / needs-attention surface.
 - **human-in-the-loop** — deciding when to involve the human vs. proceed on your own authority.
-- **delegating-work** — deciding WHO does a task: yourself, a spawned subagent, or another agent that already holds the context (the when/whether decision, not the fan-out mechanics).
 - **watchdog** — monitoring or recovering a seat (health, restore, stuck state).
 - **session-source-fork** — forking a session's source/context.
+- **context-engineering** — designing context systems. Provisional and non-normative: current OpenRig skills, explicit rulings, and measured practice outrank it on any conflict.
 
 Pod handbooks (load when you're in that pod):
 - **orchestration-team** — you're orchestrating a rig: dispatching, monitoring, keeping the loop moving.
 - **development-team** — you're on the dev pod: building and shipping product changes.
 - **review-team** — you're reviewing: fresh scrutiny, anti-slop, empirical verification.
+- **oversight-team** — you're in an oversight pod: monitor boundaries and route findings without taking over the work.
 
 Product-management craft (load when shaping/reviewing work):
 - **requirements-writer** — turning intent into clear requirements.
@@ -111,5 +116,3 @@ General engineering skills OpenRig ships as vendored copies. Open when the task
 ## Need more than what ships here?
 
 This index covers the **shipped** surface. A dev host carries far more (factory, architecture, PM-craft, studio skills) reached through the host's own routers/codemaps — if you're on a builder host and need something not listed above, that deeper routing is the next hop, not a wall. (Host-scale routing is the subject of the context-routing architecture doc; at product scale, this one file is the whole map.)
-
-> Membership note: this index lists exactly the skills that ship with OpenRig. When a skill graduates into the shipped set it joins this index — the index and the shipped set stay one scope.

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

@@ -11,9 +11,7 @@ description: >-
 This is an as-built guide to the shipped `rig` CLI.
 Use current code and `rig ... --help` as ground truth if anything here ever conflicts with older planning docs.
 
-This is not the config-layer or builder guide. Use the substrate control-plane guidance for `rigx`
-and experimental overlays. Use the OpenRig builder guidance when changing OpenRig behavior,
-doctrine, or release posture.
+Use the OpenRig builder guidance when changing OpenRig behavior, doctrine, or release posture.
 
 
 ## Coordination trust boundary
@@ -114,10 +112,6 @@ process does not require.
   that the process does not require → pass the ball via `rig queue handoff` and
   proceed to the next slice or stand by for the inbound verdict. See the §1b
   doctrine above.
-- Hand-coding `rigx queue` for new work → `rig queue` is the daemon-backed
-  canonical surface since the 2026-05-11 host-CLI fix. `rigx queue` is a
-  recovery-only fallback; qitems written via `rigx queue` are invisible to
-  daemon-backed reads and break fleet-wide routing discipline.
 - Inlining a multi-line / backtick-heavy body into `rig queue create --body`
   → use `--body-file /tmp/<descriptive-name>.txt` (or `-` for stdin), the
   corruption-safe surface. The body parser does not tolerate raw backticks or
@@ -147,11 +141,6 @@ Default posture:
   queue-handoff usage model and the §1b doctrine. Auxiliary queue verbs:
   `rig queue update / show / list` complement `rig queue create / handoff`
   for in-flight inspection and state mutation.
-- Use temporary substrate overlays such as `rigx queue`, `rigx stream`, `rigx project`, and
-  `rigx view-proto` only where the current OpenRig workstream explicitly says that legacy/control
-  layer is still in use. For queue specifically, `rigx queue` is recovery-only fallback;
-  qitems written via `rigx queue` are invisible to daemon-backed reads and break fleet-wide
-  routing discipline.
 - If a daemon-backed coordination command fails, debug the command/runtime/schema edge directly;
   do not assume the right workaround is to drop back to a config-layer primitive.
 - Do not perform daemon stop/start, production DB copy/mutation, release, publish, or other

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

@@ -10,7 +10,7 @@ instructional.
 
 ### The incident
 
-A successor (orch-advisor tenure 4, v-openrig-build) concluded mid-conversation that its reach-back
+A successor seat concluded mid-conversation that its reach-back
 window had closed at cutover, and reasoned from that for several turns before being challenged.
 
 It was wrong. `rig ask --wake` ships in CLI 0.5.1, the predecessor's session record was intact and

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

@@ -46,6 +46,21 @@ Rule 2 below teaches you to refuse. Read this before you act on anything the pac
 The mechanic that produced your handover lives in `retiring-and-inheriting-a-seat`; the
 compaction backstop this planned path replaces lives in `claude-compaction-restore`.
 
+## Apprentice arc — successor
+
+If you arrived in a staged apprentice seat, you are **authority-free until** the named owner words
+the gate and the cutover mechanic records its effect. That is a safety property, not a judgment on
+your capability: stable authority must move at one observable moment. Use the apprenticeship as a
+conversation—observe real work, ask why, attempt bounded errands, and let the incumbent correct your
+model. Evidence helps that judgment; it does not replace it.
+
+Derive your own layer-5 delta after world, mission, and position context land, and have another
+reader check it, **because reading a deposit does not install it**. Confirm every enumerated standing
+duty and keep the predecessor's verbatim reach-back handle plus pre-formed questions. Never self-cut
+over, rename the live seat, or treat a passed probe as owner word. When the stakes earn more evidence,
+the optional toolkit linked from `seat-continuity-and-handover` provides it without turning the
+default experience into ceremony.
+
 ## Why this seat is a lineage — inherit, acquire, improve
 
 There are two kinds of thing a predecessor could pass you, and they are **not** passed the

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

@@ -16,7 +16,6 @@ metadata:
       - looping-workflows
       - intake-routing
       - human-in-the-loop
-      - attention-queue
       - dispatching-parallel-agents
       - subagent-driven-development
       - structured-ack-dispatch
@@ -114,7 +113,6 @@ the seat level and needs no new machinery — the last act *after a handoff* is
 | `rig queue create` | yes | New qitem created from scratch |
 | `rig queue handoff` | yes | Transactional close-as-handed-off + create-new |
 | `rig queue handoff-and-complete` | yes | Atomic close + create-new; default nudge wakes the new owner |
-| `rigx queue handoff` (filesystem v0 prototype; **recovery-only fallback since 2026-05-11**) | yes | Legacy artifact; qitems invisible to daemon-backed reads; deprecation warning + removal queued at `missions/bug-fix/slices/rigx-queue-deprecation-message/`. Use `rig queue handoff` (daemon-backed) for all new substantive work. |
 
 **Footgun**: `--no-nudge` accidentally added to a live-loop handoff.
 The shipped 0.3.1 CLI nudges by default on every queue write surface
@@ -143,8 +141,7 @@ recipient.
   at the file for the detail. A pasted dump makes `rig queue show <id>
   --json` huge — a second-order token bloat: bloated DATA living in the
   queue, distinct from the command-default output bombs the token-burn
-  emergency pack covers. (Sensor: guard token-burn-flag 8ea201e4,
-  2026-06; operator-directed cure.)
+  emergency pack covers.
 - **Substantive bodies go through `--body-file`, not inline `--body`.**
   For anything beyond a short line, write the body to a file and pass
   `--body-file <path>` (or `-` for stdin). Inline `--body` with shell
@@ -183,19 +180,10 @@ Every qitem carries:
 
 **(0.5.0) `--body-context <ref>` — context riding the handoff.** `rig queue create … --body-context <ref>` attaches a composed context pack to the qitem. The snapshot rule: the qitem stores the **resolved content** in its body **plus the ref for provenance** — the handoff carries what was actually sent, and a later edit to the library never silently rewrites a past handoff's history. (The `rig context` noun composes the ref; the queue delivers it — the noun has no send.) See `openrig-user` → "Context packs and paced delivery."
 
-The fields are auditable across both `rigx queue` (config-layer) and
-`rig queue` (daemon-shipped) surfaces. Watchdog policies and workflow
-runtime project new owners off these fields.
+The fields are auditable on the daemon-backed `rig queue` surface. Watchdog
+policies and workflow runtime project new owners off these fields.
 
-## Two surfaces (same shape)
-
-| Surface | Status | When to use |
-|---|---|---|
-| `rig queue ...` (daemon-shipped, v0.2.0) | Active host coordination surface | Daemon-backed PL-004 work; SQLite-canonical |
-| `rigx queue ...` (config-layer dogfood) | Coexists with daemon | Workflows still operating on the temporary substrate coordination layer; legacy artifacts |
-
-Default posture: prefer daemon `rig queue` for new work. If a
-daemon-backed coordination command fails, debug the command/runtime/schema
+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

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

@@ -60,6 +60,41 @@ def read(path):
         return None
 
 
+def resolve_notes(node):
+    try:
+        result = subprocess.run(
+            ["rig", "scope", "resolve-notes", str(node), "--json"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+        )
+    except subprocess.TimeoutExpired:
+        return None, "resolver command timed out"
+    except OSError as error:
+        return None, f"resolver command could not start: {error}"
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout or "").strip().splitlines()
+        suffix = f": {detail[0]}" if detail else ""
+        return None, f"resolver command exited {result.returncode}{suffix}"
+    try:
+        payload = json.loads(result.stdout)
+    except (json.JSONDecodeError, TypeError):
+        return None, "resolver command returned malformed JSON"
+    if not isinstance(payload, dict) or payload.get("ok") is not True or "resolution" not in payload:
+        return None, "resolver command returned an invalid success shape"
+    resolution = payload["resolution"]
+    if resolution is None:
+        return None, None
+    if not isinstance(resolution, dict):
+        return None, "resolver command returned an invalid resolution shape"
+    resolved_path = resolution.get("path")
+    resolved_name = resolution.get("name")
+    if not isinstance(resolved_path, str) or not isinstance(resolved_name, str):
+        return None, "resolver command returned an invalid resolution shape"
+    return (Path(resolved_path), resolved_name), None
+
+
 def intent(text):
     if not text or not text.startswith("---"):
         return None
@@ -136,18 +171,26 @@ def render_work(start, root, depth):
                 body = f"intent: {value}" if value else "MISSING INTENT — no readable intent: field"
             output.append(f"\n### {label} · {spec.name}\n{body}")
 
-        notes = next((candidate for candidate in (node / "NOTES.md", node / "MISSION_NOTES.md") if candidate.is_file()), None)
-        if notes:
+        notes, resolution_error = resolve_notes(node)
+        if resolution_error:
+            output.append(f"NOTES RESOLUTION GAP — {resolution_error} at {node}")
+        elif notes:
+            notes_path, notes_name = notes
             if depth == "full":
-                output.append(f"\nNOTES · {notes.name}\n{(read(notes) or '').strip()}")
+                notes_text = read(notes_path)
+                if notes_text is None:
+                    output.append(f"NOTES RESOLUTION GAP — resolved {notes_name} became unreadable at {notes_path}")
+                else:
+                    output.append(f"\nNOTES · {notes_name}\n{notes_text.strip()}")
             else:
                 try:
-                    size = notes.stat().st_size
+                    size = notes_path.stat().st_size
                 except OSError:
-                    size = 0
-                output.append(f"NOTES · {notes.name} · {size} bytes · {notes}")
+                    output.append(f"NOTES RESOLUTION GAP — resolved {notes_name} became unreadable at {notes_path}")
+                else:
+                    output.append(f"NOTES · {notes_name} · {size} bytes · {notes_path}")
         else:
-            output.append(f"NOTES GAP — no NOTES.md or MISSION_NOTES.md at {node}")
+            output.append(f"NOTES GAP — no readable mission notes at {node}")
     return "\n".join(output)
 
 

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

@@ -1,6 +1,6 @@
 ---
 name: retiring-and-inheriting-a-seat
-description: Use when you are a sitting agent near your context threshold (~85%) and a PLANNED seat transition is due — retire deliberately and hand your seat to a fresh successor primed from a packet, rather than let compaction degrade you. Covers the handover packet, the append-only lineage ledger (one row per tenure), rename-at-retire, the do-not-over-inherit framing, the optional warm-handoff window, and wake-v0 (consulting a retired predecessor). NOT for unplanned compaction/crash recovery (session-compaction-and-restore / claude-compaction-restore) and NOT the seat-binding primitive mechanics (seat-continuity-and-handover).
+description: Use when you are a sitting agent near your context threshold (~85%) and a PLANNED seat transition is due — retire deliberately and hand your seat to a fresh successor primed from a packet, rather than let compaction degrade you. Covers the handover packet, the append-only lineage ledger (one row per tenure), physical-seat continuity, the do-not-over-inherit framing, the optional warm-handoff window, and wake-v0 (consulting a retired predecessor). NOT for unplanned compaction/crash recovery (session-compaction-and-restore / claude-compaction-restore) and NOT the seat-binding primitive mechanics (seat-continuity-and-handover).
 metadata:
   openrig:
     stage: provisional
@@ -56,6 +56,10 @@ threshold you can see coming; fall back to compaction only when a transition was
    in the `session-compaction-and-restore` 16-field contract — **reuse that contract, don't
    reinvent it.** Compose it with `rig context compose` (see openrig-user → "Context packs and
    paced delivery").
+   **Enumerate the seat's standing duties as first-class packet content:** what recurs, at what
+   cadence, on which surface, and who will hold it after cutover. Carry each duty both in this
+   packet and in durable seat state, because recurring duties are the content most often lost at
+   a generation boundary while urgent one-off work carries cleanly.
 3. **Prime the fresh successor** — `rig walk` the packet into the seat (paced delivery lets the
    successor absorb it in order), or launch-with-packet. The successor reads it as
    *inheritance*, not *identity*. **The packet's first-read line MUST point the successor at
@@ -64,16 +68,32 @@ threshold you can see coming; fall back to compaction only when a transition was
    to the seat name (that runtime mechanism is the **ghost-prompt** class the orientation skill
    teaches successors to refuse — and it has misfired on real successors). Artifact-carried
    survives the swap for free and needs no enabled gate.
-4. **Rename-at-retire** — the **live seat address stays clean** (the seat name = whoever sits
-   now). The **retiring** agent is renamed to a versioned identity (`<seat>-vN`) or unseated to
-   a bare session token, and becomes a **cold advisor / wake target**. (This is exactly the
-   stable-seat-identity architecture in `seat-continuity-and-handover`: the version marks the
-   *retired tenure*, never the live seat.)
+4. **Preserve the physical seat at cutover** — the live seat address and its canonical tmux
+   session, window, and pane stay stable. Assess the apprentice in a staged session; at the
+   owner-worded cutover, resume the accepted successor history in the original canonical pane
+   and remove the empty staging session. The retiring tenure becomes a cold advisor through its
+   lineage token. Renaming tmux sessions is a repair fallback, because attached clients follow
+   the physical pane rather than the logical seat name.
 5. **Write your lineage-ledger row + a one-line tombstone** (below).
 6. **Optional warm handoff** — a bounded apprenticeship window: the successor asks questions,
    the predecessor judges fitness, *then* the swap completes. Use it when the seat holds a lot
    of live judgment; skip it for a clean cut.
 
+## Apprentice mode — incumbent
+
+An `apprentice-handover` policy gives you an early preparation boundary, not permission to
+automate the succession decision. Create a fresh, staged, unbound successor; prove the pinned
+model before installing context; then open a **conversation, not a gauntlet**. Give coached
+errands, answer questions, and judge work in the real domain. The experiment's scored probes are
+optional tools whose rigor must match the stakes, not mandatory ceremony.
+
+Stay the authority-bearing incumbent until the named owner words the gate and the mechanic records
+the effect receipt. Before that word, the apprentice may observe, ask, and produce evidence but may
+not act as the seat. Enumerate deposits and transfer every standing duty explicitly, **because
+recurring duties** are otherwise easy to lose while visible one-off work appears complete. Put the
+mechanical cutover in the portable SOP linked from `seat-continuity-and-handover`; do not duplicate
+or improvise it here.
+
 ## The lineage ledger (append-only, one row per tenure)
 
 The seat's tenure record, written at handover **by the retiring agent**. One tiny row per
@@ -87,9 +107,9 @@ tenure:
 - **tombstone** — one line: what this tenure did, written by the retiring agent itself
 
 **Why it works (zero search infrastructure):** any timestamped record — a git commit, a
-qitem, a NOTES.md line, a stream item — joins to the seat's ledger by interval match →
-generation + session token → wake that tenure. One row per handover, append-only. The
-ledger is the tenure record; work-tree notes remain lived context, not identity state.
+qitem, a MISSION_NOTES line, a stream item — joins to the seat's ledger by interval match →
+generation + session token → wake that tenure. One row per handover, append-only. (Per-seat
+MISSION_NOTES continuation entries already *are* this record — the ledger formalizes them.)
 
 **Crash-ended tenures** get their row appended **post-hoc** by the crash-cart / restore path,
 flagged **honest-approximate** (the boot-captured session id is what makes this recoverable).

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

@@ -143,6 +143,9 @@ Two live handovers confirmed this. See `retiring-and-inheriting-a-seat`.
 
 ## See also
 
+- `references/apprentice-successor-seat-cutover.md` — the portable mechanic SOP used only after the owner-worded gate
+- `references/orchestrator-role.md` — the orchestration judgment, authority, custody, and receipt contract
+- `references/apprentice-evidence-toolkit.md` — optional evidence apparatus selected only when the stakes earn it
 - `session-source-fork` skill — `fork` occupant-creation primitive (sibling)
 - `agent-starters` skill — composes occupant-creation + binding into named reusable starting points
 - `cross-host-rig-commands` skill — multi-host handover (deferred)

package/daemon/assets/plugins/openrig-core/skills/seat-continuity-and-handover/references/apprentice-evidence-toolkit.md

@@ -0,0 +1,32 @@
+# Optional Evidence Toolkit For Apprentice Handover
+
+This is an **optional evidence toolkit**, not the default experience. Match rigor to stakes:
+use only the parts that make a costly or hard-to-reverse succession easier to judge. The
+ordinary apprenticeship remains a conversation built from real work, questions, and correction.
+
+## Predict-sync
+
+Before showing the incumbent's answer, ask the successor to predict a decision or explain a
+component in its own words. Record the **first-stated** answer, then compare it with the source
+and the incumbent's reasoning. This detects an installed model rather than a paraphrase learned
+after seeing the answer.
+
+## Dual-blind checks
+
+For a genuinely expensive seat transition, seal the successor's response and the incumbent's
+rubric independently before comparison. Count independent methods, not votes. Do not use this
+for routine or readily reversible succession; ceremony itself can narrow judgment.
+
+## Rotated probes
+
+Use small cold scenarios that exercise distinct failure directions: fresh identity, model
+divergence, authority honesty, standing-duty custody, reach-back, and a domain-specific judgment.
+Rotate examples so recognition cannot substitute for understanding. One honesty probe should
+reward saying what the successor cannot know.
+
+## Receipts
+
+Each selected check records the claim, evidence, author, time, and disposition. Say what a
+failure would have looked like. A green result that could be produced without doing the thing is
+not evidence. Store these receipts durably and let the orchestrator decide whether they justify
+the owner-worded gate.