@openrig/cli 0.5.3 → 0.5.5

package/daemon/assets/plugins/openrig-core/skills/openrig-operating-model/scripts/scaffold.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# scaffold.sh topology <root> --node <relpath> [--node <relpath> ...]
+# scaffold.sh work     <root> --node <relpath> [--node <relpath> ...]
+# Creates missing chain files from templates at root + each named node dir.
+# NEVER overwrites an existing file (brownfield-safe by construction; greenfield
+# and brownfield are the same command with different starting states).
+# Never deletes anything. Reports created vs existing.
+set -euo pipefail
+MODE="${1:?usage: scaffold.sh <topology|work> <root> --node <relpath> ...}"
+ROOT="${2:?root dir required}"; shift 2
+HERE="$(cd "$(dirname "$0")" && pwd)"; TPL="$HERE/../templates"
+case "$MODE" in
+  # Chains carry knowledge about a POSITION. SOP.md is knowledge about a KIND and now ships
+  # in the rig's mode plugin (openrig-lab | openrig-factory | openrig-hq) — it is NOT a chain
+  # and must not be scaffolded onto the tree. CULTURE.md ships with OpenRig.
+  topology) FILES=(LEARNED.md) ; ROOT_FILES=(LEARNED.md) ;;
+  # SPEC.md is the authored node (intent: in frontmatter). NOTES.md is the LIVED file — the
+  # scaffold creates its surface only; lived entries are never generated or projected. PROGRESS is derived;
+  # PROOF.md is authored by the prover when there is something to prove.
+  work)     FILES=(SPEC.md NOTES.md) ; ROOT_FILES=(SPEC.md NOTES.md) ;;
+  *) echo "mode must be topology|work" >&2; exit 2 ;;
+esac
+NODES=()
+while [[ $# -gt 0 ]]; do case "$1" in --node) NODES+=("$2"); shift 2;; *) echo "unknown arg $1" >&2; exit 2;; esac; done
+place(){ # $1=dir $2=file
+  mkdir -p "$1"
+  if [[ -e "$1/$2" ]]; then echo "  exists : $1/$2"
+  else cp "$TPL/$2" "$1/$2"; echo "  CREATED: $1/$2 (template — UNSEEDED; the real owner seeds it)"; fi
+}
+echo "scaffold $MODE @ $ROOT"
+touch "$ROOT/.compose-root" 2>/dev/null || true
+for f in "${ROOT_FILES[@]}"; do place "$ROOT" "$f"; done
+for n in ${NODES[@]+"${NODES[@]}"}; do for f in "${FILES[@]}"; do place "$ROOT/$n" "$f"; done; done
+echo "done. Rules: existing files untouched; UNSEEDED templates await their owners; seat LEARNED.md is SELF-seeded (the audit) — never bulk-filled."

package/daemon/assets/plugins/openrig-core/skills/openrig-operating-model/scripts/trace-due.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# trace-due.sh <seat-dir> [work-dir ...]
+# Deterministic due-check for the alignment trace. Exit 0 + reason when DUE;
+# exit 1 SILENTLY when not (the no-op path is the point: schedulers may fire
+# this on cadence; the ACTION stays evidence-gated — fixed-cadence traces were
+# empirically falsified; see SKILL.md §4).
+set -euo pipefail
+SEAT_DIR="${1:?usage: trace-due.sh <seat-dir> [work-dir ...]}"; shift || true
+STAMP="$SEAT_DIR/.last-trace"
+MIN_HOURS="${TRACE_MIN_HOURS:-6}"      # never due more often than this
+FORCE_HOURS="${TRACE_FORCE_HOURS:-72}" # due regardless of activity after this
+now=$(date +%s)
+if [[ ! -f "$STAMP" ]]; then
+  # never traced: due only if the seat shows any life at all
+  if [[ -n "$(find "$SEAT_DIR" "$@" -type f -newermt '-7 days' -print -quit 2>/dev/null)" ]]; then
+    echo "DUE: no trace on record and recent activity exists"; exit 0
+  fi
+  exit 1
+fi
+last=$(stat -f %m "$STAMP" 2>/dev/null || stat -c %Y "$STAMP")  # BSD then GNU; date -r means different things on the two OSes
+age_h=$(( (now - last) / 3600 ))
+(( age_h < MIN_HOURS )) && exit 1
+if (( age_h >= FORCE_HOURS )); then
+  echo "DUE: ${age_h}h since last trace (force threshold ${FORCE_HOURS}h)"; exit 0
+fi
+# due only if meaningful work accumulated since the stamp
+for d in "$SEAT_DIR" "$@"; do
+  if [[ -n "$(find "$d" -type f -newer "$STAMP" ! -name '.last-trace' -print -quit 2>/dev/null)" ]]; then
+    echo "DUE: ${age_h}h since last trace and new activity under $d"; exit 0
+  fi
+done
+exit 1

package/daemon/assets/plugins/openrig-core/skills/openrig-operating-model/scripts/trace-stamp.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# trace-stamp.sh <seat-dir>  — record that a trace was performed now.
+set -euo pipefail
+touch "${1:?usage: trace-stamp.sh <seat-dir>}/.last-trace"
+echo "stamped: $1/.last-trace ($(date '+%Y-%m-%d %H:%M %Z'))"

package/daemon/assets/plugins/openrig-core/skills/openrig-operating-model/scripts/trunk-diff.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# trunk-diff.sh <root-dir> <state-file> [--name FILE ...]
+# The governance pull loop: render the subtree, diff against your PREVIOUS
+# render, update state. Reading the diff = updating your mental model of a
+# changing topology without reading everything or being told anything.
+set -euo pipefail
+ROOT="${1:?usage: trunk-diff.sh <root-dir> <state-file> [--name FILE ...]}"
+STATE="${2:?state-file required}"; shift 2
+NAMES=("$@"); [[ ${#NAMES[@]} -eq 0 ]] && NAMES=(--name CULTURE.md --name PLAYBOOK.md --name LEARNED.md --name INTENT.md)
+HERE="$(cd "$(dirname "$0")" && pwd)"
+NEW="$(mktemp)"
+python3 "$HERE/compose.py" down "$ROOT" "${NAMES[@]}" | grep -v '^<!-- GENERATED' > "$NEW"
+if [[ -f "$STATE" ]]; then
+  if diff -u "$STATE" "$NEW"; then echo "── no changes since your last render ──"; fi
+else
+  echo "── first render (no previous state); full content is the baseline ──"
+fi
+mv "$NEW" "$STATE"

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

@@ -0,0 +1,40 @@
+---
+seat: <pod>-<member>@<rig>            # or rig/pod/fleet coords at higher altitudes
+template: <path-or-name of PLAYBOOK.md this diffs against> @ <version/sha>
+owners: self (sole direct writer) · <orchestrator/PM> (by proposal) · hierarchy (boundaries only, marked)
+updated: <YYYY-MM-DD from the clock command — never mental math>
+status: UNSEEDED  # the first real occupant replaces this line with: seeded-by-self <date>
+---
+# LEARNED — <instance coords>
+<!-- HARD CAP ~150 lines. At the cap: distill LESSONS into HOW I WORK, or expire them. -->
+
+## MY JOB HERE (≤10 lines)
+<!-- This instance's actual function, in operational terms. If you cannot write
+     this section yourself, say so to your orchestrator — that discovery is the
+     audit working, not a failure. -->
+
+## STANDING DUTIES
+<!-- One per line: DUTY — cadence — surface. These survive handovers ONLY if
+     enumerated here. -->
+- 
+
+## HOW I WORK
+<!-- Learned SOP bullets. EVERY bullet carries its reason — a rule without its
+     why is scripture and will be misapplied. -->
+- 
+
+## GATES & AUTHORITIES
+<!-- What I hold (granted in writing, cite the grant). What I must never infer. -->
+- 
+
+## KEY RELATIONSHIPS
+<!-- who I hand to · who gates me · whose funnel I feed -->
+- 
+
+## TRIGGER POINTERS
+<!-- situation → read this. Attach pointers to MOMENTS, not to boot. -->
+- 
+
+## LESSONS (append-only, dated, capped)
+<!-- newest first. At cap: distill upward or expire. -->
+- 

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

@@ -0,0 +1,9 @@
+---
+node: <mission | slice>
+updated: <YYYY-MM-DD>
+---
+# NOTES — <node>
+<!-- The working record: what actually happened doing this work. Append-only,
+     dated entries, newest first. Corrections annotated, never swapped.
+     Seat-specific learnings do NOT belong here — they go to that seat's
+     LEARNED.md (this file is the WORK's memory, not the worker's). -->

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

@@ -0,0 +1,5 @@
+# MOVED — this file is now SOP.md
+
+Renamed PLAYBOOK.md -> SOP.md per owner naming ruling 2026-08-11 (names are
+prompts; SOP is the stronger consult-and-follow trigger and the factory-native
+term). Read ./SOP.md. One-transition-period pointer; do not edit here.

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

@@ -0,0 +1,24 @@
+---
+kind: <seat-type | pod-type | rig-type | fleet>
+owner: <spec author>                   # instances NEVER edit this file
+updated: <YYYY-MM-DD>
+status: UNSEEDED
+---
+# SOP — <kind>
+<!-- The TEMPLATE half: how this KIND of thing does its job, anywhere it is
+     instantiated. Absorbs the static role file at seat altitude. Instance-local
+     knowledge belongs in LEARNED.md beside this, never here. -->
+
+## PURPOSE
+<!-- what this kind exists to do -->
+
+## CORE LOOP
+<!-- the job's shape: inputs → work → outputs/handoffs -->
+
+## DEFAULT PRACTICES
+<!-- each with its reason attached -->
+- 
+
+## BOUNDARIES
+<!-- what this kind never does; where its authority ends -->
+- 

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

@@ -0,0 +1,54 @@
+---
+node: <project | mission | slice>
+intent: >-
+  <ONE sentence: what this node is FOR. This composes UP the chain, so write it to be
+   read from below by someone standing on a slice. Say the purpose, never the location —
+   "deferred features land here" is a routing rule and orients nobody.>
+id: <OPR.x.y[.n] — minted by the PM; omit if unminted>
+stage: wip
+# stage: wip | provisional | established | canonical | superseded | retired
+status: UNSEEDED
+---
+
+<!-- ONE authored file per work node. README.md and IMPLEMENTATION-PRD.md fold into this.
+     PROOF.md stays separate and is good. PROGRESS.md is the authored acceptance checklist:
+     checkbox items are stored marks; every roll-up above them is derived, never hand-authored.
+     Legacy README.md nodes stay valid indefinitely; nothing is forced to migrate.
+
+     PROJECT and MISSION nodes: the frontmatter `intent:` IS the whole job. A mission
+     ORGANISES slices and carries the context they need; it specifies nothing. Keep the
+     body short or delete it — everything below this line is for SLICES.
+
+     WHATEVER BODY YOU DO WRITE, two tests per sentence:
+       PORTABILITY — if it would read correctly on a stranger's machine it is knowledge
+         about a KIND; it belongs in the operating-model skill, not on the tree.
+       VOLATILITY — a SHA, a count, a status, a roster: write the COMMAND that derives it,
+         never the answer. A value here is stale by the next fold.
+     And check the tree: traps and how-we-work live in LEARNED.md on the topology tree,
+     not here. This file is what is being BUILT.
+
+     SLICE nodes are the ONLY altitude that specifies. Keep the sections you need and
+     delete the rest; this is a starting shape, not a contract. Under the FACTORY operating
+     model this node also carries mini-requirements and a proof contract — see that mode's
+     plugin. Under the LAB it does not. -->
+
+# <name>
+
+## What must be built
+
+<!-- The change itself, at the altitude a builder can act on. -->
+
+## Why this is the shape
+
+<!-- The reasoning a reader would otherwise have to reconstruct — especially any option
+     considered and rejected. This is the part that survives you. -->
+
+## How we will know it works
+
+<!-- Verified by EFFECT: run it, look at the result. Name the command and what it should
+     print, not the feeling of being done. -->
+
+## Scope fences
+
+<!-- What this deliberately does NOT include, so it neither swallows the release nor grows
+     during the build. Fences written after the fact are excuses; written now they hold. -->

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

@@ -44,11 +44,16 @@ shows an operator — `get` is the agent-facing pull.)
 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.
 - **claude-compaction-restore** — you just compacted (Claude). Restore from durable evidence before resuming real work.
 - **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.
 - **messaging-the-human** — composing a message to the human. Plain language, no insider jargon.
 - **software-for-agents** — you want the full first-load model of how agent software is built and operated here.

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

@@ -0,0 +1,31 @@
+---
+name: refocusing
+description: >-
+  Use when a long-running agent may have lost the product outcome, when context was compacted,
+  when work has crossed a major boundary, or when a fresh path-based trace is needed before the
+  next consequential action. Not for fresh-session orientation, waking an idle seat, or checkpoints.
+metadata:
+  openrig:
+    stage: product
+---
+
+# Refocusing
+
+Refocus preserves a long session's earned expertise while re-grounding it in current intent and
+lived context. It is not a restart, wake, or phase checkpoint.
+
+Run the bundled trace from this skill directory instead of reconstructing the hierarchy from memory:
+
+```bash
+python3 scripts/trace-to-root.py --trees both --depth light
+```
+
+Use `--trees topology|work|both` to select context domains and `--depth light|full` to control how
+much each node contributes. Light work traces compose `intent:` and name notes; full traces include
+the complete node and notes bodies. The script resolves `topology.root` and `workspace.root` with
+`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.
+
+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/references/refocus.md

@@ -0,0 +1,22 @@
+# Refocus
+
+1. What is the person actually trying to get? Not your current task — the outcome.
+2. Does what you are doing RIGHT NOW move that? If you cannot say what a user gets, stop and say so.
+3. What have you concluded without opening the file or running the thing?
+
+Discomfort on any of these is the signal: drift feels like work.
+
+The `refocusing` skill carries the source-appropriate path-only trace. Its
+`scripts/trace-to-root.py` walks both current trees by default: topology `LEARNED.md`, then work
+`SPEC.md` intent plus `NOTES.md`. Change breadth with `OPENRIG_REFOCUS_TREES=topology|work|both`
+and read depth with `OPENRIG_REFOCUS_DEPTH=light|full`.
+
+Replace this default without editing the plugin. The content ladder, highest precedence first, is:
+
+1. `OPENRIG_REFOCUS_CONTENT_REF`, resolved by `rig context get`.
+2. `OPENRIG_REFOCUS_CONTENT_FILE`, an operator-authored file.
+3. `$OPENRIG_HOME/refocus/REFOCUS.md`, instance content.
+4. This shipped default.
+
+Fresh seats receive the separate onboarding assets `openrig-onboarding-01.md` and
+`openrig-onboarding-02.md`. This file only cites those assets; it does not copy their world install.

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

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""Render topology and work context by ascending directory paths only."""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+from pathlib import Path
+
+SHELVES = {"rigs", "pods", "seats", "missions", "slices"}
+
+
+def rig_output(*args):
+    try:
+        result = subprocess.run(
+            ["rig", *args], capture_output=True, text=True, timeout=10, check=False
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    value = (result.stdout or "").strip()
+    return value if result.returncode == 0 and value else None
+
+
+def configured_root(key, env_key):
+    value = os.environ.get(env_key) or rig_output("config", "get", key)
+    return Path(value).expanduser().resolve() if value else None
+
+
+def under_root(path, root):
+    try:
+        path.relative_to(root)
+        return True
+    except ValueError:
+        return False
+
+
+def ascent(start, root):
+    start = start.expanduser().resolve()
+    if not under_root(start, root):
+        return None, f"start is outside configured root: {start}"
+    nodes = []
+    current = start
+    while True:
+        if current.name not in SHELVES:
+            nodes.append(current)
+        if current == root:
+            break
+        parent = current.parent
+        if parent == current:
+            return None, f"could not reach configured root: {root}"
+        current = parent
+    return list(reversed(nodes)), None
+
+
+def read(path):
+    try:
+        return path.read_text(encoding="utf8", errors="replace")
+    except OSError:
+        return None
+
+
+def intent(text):
+    if not text or not text.startswith("---"):
+        return None
+    match = re.match(r"^---\s*\n(.*?)\n---(?:\s*\n|$)", text, re.S)
+    if not match:
+        return None
+    lines = match.group(1).splitlines()
+    for index, line in enumerate(lines):
+        found = re.match(r"^intent:\s*(.*)$", line)
+        if not found:
+            continue
+        value = found.group(1).strip()
+        if value in {"|", ">", "|-", ">-", "|+", ">+"}:
+            block = []
+            for later in lines[index + 1:]:
+                if later and not later[0].isspace():
+                    break
+                block.append(later.strip())
+            return " ".join(part for part in block if part)
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}:
+            if value[0] == '"':
+                try:
+                    return json.loads(value)
+                except json.JSONDecodeError:
+                    pass
+            return value[1:-1]
+        return value or None
+    return None
+
+
+def light_learned(text):
+    if not text:
+        return ""
+    body = re.sub(r"^---\s*\n.*?\n---\s*\n", "", text, count=1, flags=re.S).strip()
+    if len(body) <= 800:
+        return body
+    boundary = body.rfind("\n", 0, 800)
+    return body[:boundary if boundary > 0 else 800].rstrip() + "\n[… use --depth full for the rest]"
+
+
+def render_topology(start, root, depth):
+    output = ["## TOPOLOGY TRACE", f"root: {root}", f"start: {start}"]
+    nodes, error = ascent(start, root)
+    if error:
+        return "\n".join(output + [f"TRACE GAP — {error}"])
+    for node in nodes:
+        chain_file = node / "LEARNED.md"
+        text = read(chain_file)
+        label = node.relative_to(root) or Path(".")
+        if text is None:
+            output.append(f"\n### {label}\nMISSING LINK — {chain_file}")
+            continue
+        body = text.strip() if depth == "full" else light_learned(text)
+        output.append(f"\n### {label} · LEARNED.md\n{body}")
+    return "\n".join(output)
+
+
+def render_work(start, root, depth):
+    output = ["## WORK TRACE", f"root: {root}", f"start: {start}"]
+    nodes, error = ascent(start, root)
+    if error:
+        return "\n".join(output + [f"TRACE GAP — {error}"])
+    for node in nodes:
+        label = node.relative_to(root) or Path(".")
+        spec = next((candidate for candidate in (node / "SPEC.md", node / "README.md") if candidate.is_file()), None)
+        if spec is None:
+            output.append(f"\n### {label}\nMISSING LINK — no SPEC.md or README.md at {node}")
+        else:
+            text = read(spec) or ""
+            if depth == "full":
+                body = text.strip()
+            else:
+                value = intent(text)
+                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:
+            if depth == "full":
+                output.append(f"\nNOTES · {notes.name}\n{(read(notes) or '').strip()}")
+            else:
+                try:
+                    size = notes.stat().st_size
+                except OSError:
+                    size = 0
+                output.append(f"NOTES · {notes.name} · {size} bytes · {notes}")
+        else:
+            output.append(f"NOTES GAP — no NOTES.md or MISSION_NOTES.md at {node}")
+    return "\n".join(output)
+
+
+def derive_topology_start(root):
+    explicit = os.environ.get("OPENRIG_REFOCUS_TOPOLOGY_NODE")
+    if explicit:
+        return Path(explicit)
+    raw = rig_output("whoami", "--json")
+    if not raw:
+        return None
+    try:
+        identity = json.loads(raw).get("identity", {})
+    except json.JSONDecodeError:
+        return None
+    rig = identity.get("rigName")
+    session = identity.get("sessionName")
+    if not rig or not session:
+        return None
+    seat = str(session).split("@", 1)[0]
+    return root / "rigs" / str(rig) / "seats" / seat
+
+
+def derive_work_start(root):
+    explicit = os.environ.get("OPENRIG_REFOCUS_WORK_NODE")
+    if explicit:
+        return Path(explicit)
+    current = Path.cwd().resolve()
+    if not under_root(current, root):
+        return None
+    while under_root(current, root):
+        if (current / "SPEC.md").is_file() or (current / "README.md").is_file():
+            return current
+        if current == root:
+            break
+        current = current.parent
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--trees", choices=("topology", "work", "both"), default=os.environ.get("OPENRIG_REFOCUS_TREES", "both"))
+    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")
+    args = parser.parse_args()
+
+    sections = []
+    if args.trees in {"topology", "both"}:
+        root = configured_root("topology.root", "OPENRIG_TOPOLOGY_ROOT")
+        if root is None:
+            sections.append("## TOPOLOGY TRACE\nTRACE GAP — topology.root is unresolved")
+        else:
+            start = Path(args.topology_start) if args.topology_start else derive_topology_start(root)
+            sections.append(render_topology(start, root, args.depth) if start else
+                            "## TOPOLOGY TRACE\nTRACE GAP — current topology node is unresolved; set OPENRIG_REFOCUS_TOPOLOGY_NODE")
+
+    if args.trees in {"work", "both"}:
+        root = configured_root("workspace.root", "OPENRIG_WORKSPACE_ROOT")
+        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")
+
+    print("\n\n".join(sections))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -87,9 +87,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 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.)
+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.
 
 **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/software-for-agents/SKILL.md

@@ -1,15 +1,10 @@
 ---
 name: software-for-agents
 description: |
-  Load this FIRST, before you assume how anything here works — especially before building, modifying, or
-  "fixing a bug" in an OpenRig or studio-box system, or when something behaves unexpectedly and you're
-  about to treat it as a code bug. You are almost certainly NOT operating in traditional software. This
-  is a self-improving MARKDOWN CONTROL PLANE: the substrate is markdown + YAML + JSON + folder structure
-  (skills, instructions, bootstrap files, schemas, conventions), and most "bugs" are coherence gaps in
-  that layer, not broken functions. Read this to form the correct mental model so your fixes land at the
-  precise spot that stops the footgun for every future rig — not just patch a symptom. It also covers why STUDIO APPS skip the mockup phase — for an agent-built app the build is as fast as the mockup, so the PRD is the fleshed intent (velocity as method, not a quality waiver). NOTE: the
-  bug-tolerance in this model is SCOPED to agent-managed software; the OpenRig core and rigs.to stay
-  rock-solid — see the scope block up top before you apply anything here.
+  Use when building, modifying, or diagnosing an OpenRig or studio-box system; when surprising behavior
+  looks like a code bug but may come from Markdown, YAML, JSON, bootstrap files, schemas, skills, or
+  conventions; or when deciding whether an agent-built studio app needs a separate mockup phase. NOT for
+  treating defects in OpenRig core or rigs.to as tolerable control-plane drift.
 metadata:
   openrig:
     stage: factory-approved

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

@@ -0,0 +1,11 @@
+# Public capability and source-map width for the default onboarding walk.
+name: onboarding-width
+version: "0.5.5"
+purpose: "The public capability map and source map referenced by the default onboarding walk."
+files:
+  - path: public-what-you-can-do.md
+    role: reference
+    summary: "The public OpenRig capability map."
+  - path: public-reference-material.md
+    role: reference
+    summary: "The public source map and trust guidance."

package/daemon/context-packs/{world/install/reference-material.md → onboarding-width/public-reference-material.md}

@@ -19,7 +19,7 @@ points and were written to be entered from:
   into the code and do not know which module owns the thing.
 - **`cli-reference.md` — the full `rig` command surface, ~106 KB.** Every group, subcommand, flag,
   JSON shape. **This is the authority on how a command works**, and the capabilities piece
-  (`what-you-can-do.md`) is only the map to it.
+  (`public-what-you-can-do.md`) is only the map to it.
 
 **These are maintained, not archaeology.** `cli-reference.md` alone has forty-nine commits against
 it. Treat them as current.
@@ -40,28 +40,6 @@ Each of these carries frontmatter, and three fields are worth knowing by name:
 field is how you calibrate rather than guess. Where a doc and the live binary disagree, **the
 binary wins** — and the disagreement is worth reporting, not just working around.
 
-## The corpus — under `shared-docs/` in the OpenRig home
-
-Twenty-one directories of accumulated writing. The ones you are most likely to want:
-
-| where | roughly | what it holds |
-|---|---|---|
-| `product/` | 103 files | what OpenRig is, who it is for, why it exists in this shape |
-| `conventions/` | 76 files | how things are done here — naming, scope, cadence, formats |
-| `field-notes/` | 141 files | what actually happened, written by whoever it happened to |
-| `primitives/` | 38 files | the load-bearing concepts, examined one at a time |
-| `doctrine/` | 10 files | the rulings that settled a recurring argument |
-| `corpus/` | 14 files | canon and insights, distilled |
-
-**A warning you will need, because it is not obvious from the directory names:** almost all of this
-was written to explain OpenRig **to a human**. It says *you stop being the router, the bookkeeping
-leaves your head, your job shrinks to judgment.* Read as-is, it is about somebody else.
-
-**The agent version is the same content with the subject swapped: you are the router now.** The
-bookkeeping moved to you. The judgment that was supposed to stay human is sitting in your seat.
-When you read the corpus, do that substitution as you go — otherwise you will absorb it as
-background about a user rather than as a description of your own job.
-
 ## The living answer — `--help`
 
 **The binary is always more current than anything written about it.** `rig <verb> --help` and
@@ -74,9 +52,9 @@ building a parallel solution out of primitives that already compose into the ans
 
 ## Outside the forest — when nothing on this machine can answer it
 
-**Everything above is this box.** The corpus, the as-built docs, `--help`, the disk. There is a
-whole class of question none of it reaches: what an external library actually does today, anything
-that changed after your training cutoff, what is true in the world rather than in this repo.
+There is a whole class of question the source repo and live `--help` do not reach: what an external
+library actually does today, anything that changed after your training cutoff, what is true in the
+world rather than in this repo.
 
 **And the failure is the same one this page already warns about, pointed outward.** An agent that
 does not know the corpus exists invents instead of looking. An agent that does not know these exist