@openrig/cli 0.5.5 → 0.5.7

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

@@ -1,27 +1,27 @@
 ---
 name: mission-slice-sop
-description: "Use when working on a mission or slice; editing SPEC.md, NOTES.md, PROGRESS.md, or PROOF.md; defining a proof contract or plan-lock/proof-lock; running rig proof; making a handoff; or preparing for compaction."
+description: >-
+  Use when starting, building, handing off, restoring, or closing a mission or slice under the default lightweight SDLC.
 metadata:
   openrig:
     stage: shipped
     sibling_skills:
-      - mission-slice-intent-proof-sop
       - queue-handoff
       - seat-continuity-and-handover
       - claude-compaction-restore
 ---
 
-# Mission/Slice SOP — how you work a mission & slice
+# Mission/Slice SOP — Part A
 
 Use this skill to actually **do** mission/slice work: track on the canonical files, record what you proved, hand off through them, and survive compaction on them. **Do the work described here; do not merely explain the protocol.**
 
+**Full convention SSOT:** repo `docs/reference/sdlc-conventions.md`; installed `$OPENRIG_HOME/reference/sdlc-conventions.md`. This skill is the concise Part-A teaching surface and does not replace the full convention.
+
 ## THIS IS THE LIGHT DEFAULT — read this before anything else
 
 **The default for any slice is the inner loop:** ground yourself → build → **test with your own eyes** → iterate → **ONE** full-breadth review at the end. That is the whole process. It is not a reduced form of a better process; it IS the process.
 
-**The intent / plan-lock / proof-contract / proof-lock ceremony is NOT part of this skill.** It lives in a separate overlay, **`mission-slice-intent-proof-sop`**, and you **may not select it yourself**. It applies only when the mission owner — or an orchestrator explicitly relaying the mission owner — **assigns it to a named piece of work**. If you believe something earns it, say so in one sentence and **continue on the light path** until told otherwise.
-
-Why the split exists, plainly: this document used to carry both, so every slice loaded the full apparatus and a one-line documentation change could draw a multi-round gate. If you find yourself building a proof contract, requesting a pre-edit gate, or asking a peer to gate something you can verify yourself — you have picked up the overlay without being assigned it. Put it down.
+**Part B is defined in the SSOT above and applies only when the human operator — or an orchestrator explicitly relaying that decision — assigns it to a named piece of work.** You may not select it yourself. If you believe something earns it, say so in one sentence and **continue on Part A** until told otherwise.
 
 ## Proportionality — this SOP serves shipping; it is not the work itself
 
@@ -35,21 +35,24 @@ The working product is the deliverable. This bookkeeping exists so the work surv
 
 These three are a division of labour, not a chain of gates. One agent may hold all three on a small slice.
 
-## The canonical files (the operating surface)
+## The current file contract
 
 > These files are the **operating surface of the work** — you track on them, record on them, hand off through them, and survive compaction on them. Keep them current because that is what lets the work survive. But they **serve** the product; they are not the product. If you're polishing files while the actual thing isn't shipping, you've inverted it: go build, then update them.
 
-- **SPEC.md** (mission + slice) — the one authored node file. `intent:` lives in frontmatter; the slice body specifies through `## Intent`, `## Mini-requirements`, and `## Proof contract`. Advisory sibling build-order edges live in `depends_on:`.
-- **PROGRESS.md** — the durable mission/slice acceptance checklist. In-process steps stay in the working agent's todo tool.
-- **NOTES.md** — lived context and observations that help the mission without changing its contract.
-- **PROOF.md** (+ `proof/`) — what you actually verified, stated honestly. A couple of honest, LOOKed-at lines beat an elaborate contract.
+- **Slice:** `SPEC.md`, `PROGRESS.md`, `PROOF.md`, and `proof/`.
+- **Mission:** `SPEC.md` and `NOTES.md`.
 
 ## Per-file rules — WHO / WHEN / HOW
 
+### SPEC.md
+- **WHO:** the planning owner authors it; builders and reviewers read it as the scope and intent source.
+- **WHEN:** at creation and whenever scope changes.
+- **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 mission/slice owner keeps acceptance honest.
-- **WHEN:** when an acceptance outcome changes, especially at handoff and close.
-- **HOW:** one checkbox per durable outcome. Do not copy in-process todo steps into it.
+- **WHO:** the orchestrator owns `§1` (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.
 
 ### PROOF.md + proof/
 - **WHO:** the impl/QA pair that worked the slice.
@@ -57,16 +60,13 @@ These three are a division of labour, not a chain of gates. One agent may hold a
 - **HOW:** say what you verified and how you verified it — **by effect**: you ran it and looked at the result. Put supporting media under `proof/`. State plainly what is proven and what is **not**; an honest "this half is untested" is worth more than a checkmark. If a drop verb is in play for this slice, prefer it over hand-placing files so the artifact carries its own provenance.
 
 ### NOTES.md
-- **WHO:** whoever did or observed the work.
-- **WHEN:** when lived context will help the next worker but does not belong in the contract.
-- **HOW:** write raw observations freely; point to durable artifacts instead of copying them.
-
-### SPEC.md
-- **WHO:** the node owner. **WHEN:** at creation and on a real rescope. **HOW:** keep `intent:` and advisory `depends_on:` in frontmatter; only slice bodies specify buildable work.
+- **WHO:** any agent updates `§1` (top-of-mind); each seat owns and appends to its own `§A–§X`.
+- **WHEN:** on material mission-context changes; a compacting agent **files its state here BEFORE compaction and reads it on restore.**
+- **HOW:** accruing tribal knowledge — `§1` ≤ 5–15 lines (gates, open decisions, surprises); per-seat continuation entries (latest = truth; other seats read-only). Pointer-first; don't duplicate.
 
 ## The lifecycle (4 legs)
 
-**SCAFFOLD** (`rig scope` creates the files from templates) → **POPULATE** (agents fill them as work happens) → **PROJECT** (scope readers and the TUI derive the current view) → **VERIFY** (`rig scope audit`, advisory). "Loose freeform write + deterministic verify."
+**SCAFFOLD** (`rig scope` creates the files from templates) → **POPULATE** (agents fill them as work happens) → **PROJECT** (the Living Notes UI reads them into INTENT → PLAN → DELIVERED) → **VERIFY** (`rig scope audit`, advisory). "Loose freeform write + deterministic verify."
 
 ## Hot-potato (handoffs)
 
@@ -89,7 +89,6 @@ When you `rig capture` a pane, **greyed / ghost autocomplete suggestions are NOT
 ## Moment-of-truth checklist
 
 - **Starting a slice?** → do you know what it's for and what done looks like? mockups attached (UI slices)? **Are you on the light path?** (You are, unless the mission owner assigned the overlay.)
-- **Finishing a slice?** → does PROOF.md say what you actually verified, by effect, including what is NOT covered? Acceptance updated in PROGRESS? handed off via `rig queue handoff`?
-- **Rescoping?** → update SPEC.md; ordinary implementation steps do not belong there.
-- **Compacting?** → deposit seat continuity in the seat's restore surface; NOTES.md holds only work-tree lived context.
-- **Starting on a mission?** → read the mission SPEC.md + NOTES.md + the conventions SSOT.
+- **Finishing a slice?** → does `PROOF.md` say what you actually verified, by effect, including what is NOT covered? `PROGRESS.md` updated? mission `NOTES.md` refreshed? handed off via `rig queue handoff`?
+- **Compacting?** → file your state in mission `NOTES.md`; on restore, read it plus the active slice's `SPEC.md`, `PROGRESS.md`, and `PROOF.md`.
+- **Starting on a mission?** → read mission `SPEC.md`, `NOTES.md`, and the conventions SSOT.

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

@@ -9,7 +9,7 @@ description: >-
 metadata:
   openrig:
     stage: draft
-    author: OpenRig product team (sole-context authorship; revisions per REVISION-GUIDE.md)
+    author: OpenRig product team (sole-context authorship)
 ---
 
 # The OpenRig Operating Model
@@ -25,11 +25,7 @@ write protocol). The SUPPLY layer — how canon content flows into the chains:
 addresses, maps, renders, EMM maturity, census — is `openrig-corpus-canon`,
 the deliberate drain mechanism the dual-home interim anticipated.
 
-Companion files in this skill's folder — routed, not inlined:
-- `ROLLOUT.md` — how the model is being adopted on a live fleet (waves, interim
-  practices, what happens to existing files).
-- `ROADMAP.md` — what later gets formalized in product code, and when.
-- `REVISION-GUIDE.md` — for agents revising this skill.
+Companion implementation assets in this skill's folder:
 - `templates/` and `scripts/` — starters and working tools, described in §8.
 
 ## 1. The model in one breath
@@ -380,8 +376,7 @@ living system are the same command with different starting states. Created
 files are marked UNSEEDED until their real owner writes the first true
 version. **Never mass-produce LEARNED.md content for other instances** — each
 instance writing its own first version is both how the knowledge becomes real
-and how you discover which seats can't describe their own job (see
-`ROLLOUT.md` on why that discovery is the point).
+and how you discover which seats cannot yet describe their own job.
 
 ## 10. Pitfalls (only what isn't taught above)
 
@@ -393,12 +388,10 @@ and how you discover which seats can't describe their own job (see
 - Summarizing this model for another agent instead of pointing them here —
   secondhand operating models are how operating models die; this skill was
   authored precisely because a chain of summaries destroyed the last one.
-- Scripts in `scripts/` are macOS-flavored in places (`stat -f`); on Linux,
-  check `REVISION-GUIDE.md` for the portability notes before trusting them.
+- Scripts in `scripts/` are macOS-flavored in places (`stat -f`); verify
+  platform compatibility before trusting them on another OS.
 
 ## Files in this skill
 
-`ROLLOUT.md` · `ROADMAP.md` · `REVISION-GUIDE.md` ·
-`CHANGELOG.md` — why the model is shaped this way, and what it replaced ·
 `templates/{SPEC,LEARNED,SOP}.md` ·
 `scripts/{compose.py, trace-due.sh, trace-stamp.sh, trunk-diff.sh, scaffold.sh}`

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,31 @@ 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.
+- **loading-addressable-markdown** — a task names Markdown as `path#h2-slug` or `path#h2-slug/h3-slug` outside the context-pack library.
 - **session-compaction-and-restore** — preparing for, or recovering from, compaction (any runtime). The write- and read-side protocol.
 - **queue-handoff** — you're passing durable work to another seat or ending your turn. The queue is the work ledger, not chat.
 - **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 +75,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.
@@ -100,10 +106,6 @@ General engineering skills OpenRig ships as vendored copies. Open when the task
 - **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.
-- **writing-plans** — writing an implementation plan.
-- **executing-plans** — working through a written plan.
-- **brainstorming** — divergent ideation before converging.
-- **using-superpowers** — discovering and using the vendored "superpowers" skill set.
 - **agent-browser** — driving a browser (screenshot / screencast) from an agent.
 - **frontend-design** — designing frontend / UI.
 - **dogfood** — web-QA / dogfooding a shipped UI.
@@ -111,5 +113,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