@openrig/cli 0.5.8 → 0.5.9

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

@@ -11,7 +11,7 @@ not know exists.** So the point of what follows is not skill. It is recognition:
 lands, something rhymes, and you go check instead of building.
 
 Eighty-one-plus top-level verbs ship (capability canon refreshed through
-`capability-delta-v0.5.7`). Read this once for shape, and let it make you suspicious that a thing
+`capability-delta-v0.5.9`). Read this once for shape, and let it make you suspicious that a thing
 already exists. Model-divergence proclamations are live product (trust them; pins use canonical
 model IDs).
 
@@ -32,6 +32,8 @@ one command away. Your memory of the fleet is a claim about the past.
   unless you ask for nodes.
 - **`rig discover`** — what is running on this box that OpenRig is *not* managing.
 - **`rig queue whoami`** — what the daemon thinks you are holding. Not what you remember holding.
+  When the seat's typed rows name exactly one work node, its JSON also carries `currentWork` with
+  the mission, slice, and path the refocus hook uses.
 - **`rig seat status <seat>`** — what the system already believes about a seat's handover state,
   and whether the thing you did an hour ago actually landed.
 - **`rig view list` / `rig view show <lens>`** — named lenses over coordination state: use
@@ -53,7 +55,9 @@ unseen — which makes messages the one delivery channel that never gets skipped
 - **`rig send`** — put words in front of one seat, several, a pod, or a rig. **`--verify` checks
   pane-only delivery**: the text was staged at the far end, not that the agent consumed or acted
   on it. Alternate-screen and queued-command cases can still yield false negatives, so
-  consequential delivery gets an effect check at the far end rather than a blind retry.
+  consequential delivery gets an effect check at the far end rather than a blind retry. A
+  producer-link advisory reading `no_activity_signal` means activity could not be determined;
+  confirm by effect, never relaunch on it.
 - **`rig send --raw`** / **`--dangerously-interact --reason "<why>"`** — a seat is frozen on an
   interactive prompt or a permission block. Normal `send` *refuses* to answer a prompt on purpose;
   this is the deliberate override, and it is how you unblock a peer who cannot unblock itself.
@@ -105,7 +109,8 @@ your context, your compaction and your replacement — and it is the only thing
 - **`rig queue block` / `resolve`** — park a row on a real blocker so it stays **yours and
   visible**, with a plain-language summary and a pointer to what a human must judge; `resolve`
   writes their decision onto the durable record and wakes the owner. **Closing it would be a lie
-  and sitting on it silently is indistinguishable from a crash.**
+  and sitting on it silently is indistinguishable from a crash.** `--wake-after <duration>` arms
+  one wake for this park episode; a new park supersedes it and every exit route retires it.
 - **`rig queue overdue`** — what was claimed and never closed in time. **Defaults to the current
   rig**; ask for more if you mean more.
 - **`rig queue undelivered`** — pending create-path nudge failures only. For gateway or human
@@ -127,10 +132,13 @@ you that is still running.
 
 - **`rig watchdog register`** — arm a wake for a condition that will become true after you are
   asleep, compacted or finished. For a context wall, use the exact
-  `--policy context-usage-threshold` rather than a hand-rolled transcript timer.
+  `--policy context-usage-threshold` rather than a hand-rolled transcript timer. A scheduled
+  reminder arrives as the authored message under an explicit scheduler identity, not as YAML
+  syntax or anonymous agent input.
 - **`rig watchdog list` / `show` / `status` / `stop`** — did it fire, is it still live, did someone
-  stop it. **Quiet skips are not recorded**, so a healthy idle job and a job that never ran look
-  identical in `status` — INDETERMINATE is the honest read until `show` says otherwise.
+  stop it. `list` defaults to active, compact, and 100; `--all --full` is the complete history.
+  **Quiet skips are not recorded**, so a healthy idle job and a job that never ran look identical
+  in `status` — INDETERMINATE is the honest read until `show` says otherwise.
 - **An alarm whose message has gone stale is worse than no alarm.** When the thread it refers to
   closes, kill it or rewrite it — a successor inheriting an escalation order with no thread
   attached is worse off than one with nothing.
@@ -145,6 +153,10 @@ cheaper than being it.
 - **`rig workflow specs`** — what can be started here, and which are shipped versus authored by
   this rig.
 - **`rig workflow validate`** — will this spec instantiate at all, before a run finds out for you.
+- **`rig workflow compile <mission>`** / **`instantiate-lifecycle`** — derive one executable graph
+  from `project.yaml` → `mission.yaml` → `slice.yaml`, inspect it without writing, then start an
+  eligible graph with an opaque replay key. Typed acceptance candidate, verdict, and evidence
+  travel through `workflow project`; workflow completion alone is never release acceptance.
 - **`rig workflow instantiate`** — start a multi-step, multi-seat run as one governed instance with
   an entry packet that lands on a real owner.
 - **`rig workflow status`** — **which instances need *you*, right now**, with the reason and next
@@ -171,8 +183,11 @@ not have to tear one down to change it, and you rarely have to start from nothin
 - **`rig down`** — stop a rig's seats and take it out of the running set.
 - **`rig launch <rig> [seat]`** — one seat is down; start just that one, without disturbing the
   rest.
+- **`rig seat launch <seat> --fresh --reason <why>`** — deliberately create a blank occupant for
+  exactly one existing seat. It uses no resume, fork, rebuild, snapshot, or restore packet;
+  siblings and durable work stay put, and unmanaged ambiguity refuses.
 - **`rig add`** / **`rig expand`** — graft one more member, or a whole new pod, onto a rig that is
-  already running.
+  already running. `rig grow --new-pod` and `rig expand` are one ingress; choose by input shape.
 - **`rig remove`** / **`rig shrink`** — take a seat, or an entire pod, out of a running topology.
   If it holds active work, pass `--fallback <live-seat>` to reroute before mutation; without a
   valid fallback the command refuses rather than strand the rows.
@@ -201,7 +216,8 @@ not have to tear one down to change it, and you rarely have to start from nothin
 because someone lost work once.
 
 - **`rig start`** — the box rebooted and everything is gone: bring the whole topology back in one
-  move, rather than hand-restoring rig by rig.
+  move, rather than hand-restoring rig by rig. Selected-rig recovery now demands positive runtime
+  evidence and refuses stale identity by name rather than substituting an occupant.
 - **`rig daemon start` / `stop` / `status` / `logs`** — bounce the control plane, or read what it
   actually tried and refused, in its own voice.
 - **`rig doctor`** — is the *installation* wired up correctly, or are you chasing a bug that is
@@ -213,11 +229,19 @@ because someone lost work once.
   list with their exact remediation, mid-run cancel with `c`. It only offers RESTORE on POSITIVE
   down-evidence (confirmed-down vs cannot-verify are distinct screens).
 - **`rig snapshot`** — take a restore point **before** the risky thing. `snapshot list` shows what
-  you actually have and how old the newest is.
+  you actually have and how old the newest is; `--intended-seats` records the topology roster the
+  later restore must judge rather than treating every historical node as current.
 - **`rig restore`** — put a rig back to a snapshot. **`rig restore-check` first**: what would
   actually come back, and for everything that would not, which check fails and what the fix is.
+  Use `rig launch ... --snapshot-id <id>` when selection must be exact, and `rig restore status
+  <attempt> --rig <rig>` for the derived intended-set receipt after an asynchronous restore.
 - **`rig restore-packet write` / `read` / `validate`** — a seat is about to die or must move
   runtimes; capture what it knows into a portable artifact instead of losing it with the process.
+- **Upgrading is agent-led** — load the shipped `openrig-upgrade` skill for the bounded inspect,
+  backup, plugin-refresh, and 0.5.9 instance-migration helpers. The migration is an
+  Agent-Operated Workflow: inspect, take one bounded reversible action, verify its effect, and
+  continue from the receipt. There is no `rig upgrade` verb, and `rig down` is not part of a
+  continuity-preserving upgrade.
 - **A seat's `compaction_strategy` is declared, not improvised at the wall.** Pair a threshold-
   managed seat with the `context-usage-threshold` watchdog above so continuity is arranged while
   the seat can still act.
@@ -230,6 +254,9 @@ because someone lost work once.
 - **`rig seat set-model` / `stop` / `clean`** — persist the model for later managed resumes, stop
   exactly one live seat, or clear a dead seat's stale binding. When the topology is right and only
   the occupant is wrong, use these seat lifecycle verbs or `rig handover`, not a rig down/up cycle.
+  Effective-model detection follows the identity-verified current occupant, not a retained
+  predecessor; a `<synthetic>` transcript record is skipped, so a PENDING model check is not a
+  divergence.
 - **`rig compact-plan`** → **`rig compact`** — who is near the context wall, then act on it.
   **Ordering matters: running `compact` without the plan is guessing which seat needed it.**
 - **Know what compaction costs before you reach for it.** On some runtimes what comes back has
@@ -250,7 +277,9 @@ the tooling already reads. An agent who does not know this exists invents a priv
 scheme, and nothing downstream can see it.
 
 - **`rig scope mission ls` / `show` / `create`** — what work exists, what a mission is for, and how
-  to open one so it gets a stable dot-ID rather than being a bare folder nothing can address.
+  to open one so it gets a stable dot-ID rather than being a bare folder nothing can address. In
+  `rig tui`, SCOPES → select a mission shows the same story as DONE / NOW / NEXT / ATTENTION, with
+  row drill-in and Escape back.
 - **`rig scope slice ls` / `show` / `create`** — the same at the altitude where work is actually
   buildable. `show` gives you intent, frontmatter and children without guessing which of five files
   to open.
@@ -279,8 +308,10 @@ scheme, and nothing downstream can see it.
 - **`rig workspace doctor` / `validate`** — does the daemon agree with you about where the work
   tree is, and which files are missing the frontmatter their kind requires.
 - **`rig context work-install --project … --mission … --slice … [--deliver]`** — resolves the ordered
-  context plan; add `--deliver` to emit the exact extant files in that same order while marking
-  absent pieces visibly. Without the flag it remains plan-only.
+  System World, topology, and Project World plan. Add `--runtime` to see the composed managed skill
+  loadout, `--apply-skills` to reconcile its owned harness projection, or `--deliver` to emit the
+  exact extant files in order while marking absent pieces visibly. Without the flags it remains
+  plan-only.
 - **`rig context show` / `sync` / `rm`** — what is inside a context pack before you prime a seat
   with it, and how to make the library catch up when you edit one.
 - **`rig context get <name-or-ref>`** — pull exact context by address instead of reading files:
@@ -314,12 +345,17 @@ working arrangement becomes something someone else can instantiate.
 
 - **`rig spec validate` → `preflight` → `audit`** — three different questions, in order: is the
   file well-formed, would it boot *on this host*, and **will the agents it launches actually know
-  anything when they arrive**. The third is the one people skip.
+  anything when they arrive**. The third is the one people skip. Unknown structural keys refuse
+  with their path instead of being normalized away.
+- **`rig context trace --pod <pod>`** — walk the context chain through instance → rig → pod → seat
+  when the pod altitude matters.
 - **`rig specs show` / `preview` / `add` / `sync` / `rename` / `remove`** — where a spec lives,
   what you would get if you launched it, and how to put yours in the library so it is launchable
   by bare name.
 - **`rig export <rig>`** — turn a rig that is *running right now* back into a spec you can read,
   diff or hand to someone. **`rig import`** goes the other way.
+- **`rig import <workspace.yaml> --workspace-only --target-rig <id>`** — apply a validated
+  workspace declaration to an existing rig without changing topology; `rig export` preserves it.
 - **`rig bundle create` / `inspect` / `install` / `history`** — one file that rebuilds a rig on a
   machine with none of its content, what is inside one before you trust it, and what has actually
   been installed here.
@@ -356,7 +392,9 @@ reaching them is ordinary work rather than an escalation.
 your circumstances is configuration, and the ones that are not, another agent can change for you.
 
 - **`rig config get` / `reset` / `init-workspace`** — read one value, change a system-wide setting
-  and put it back exactly as it was, or lay down the workspace tree on a box that has none.
+  and put it back exactly as it was, or additively lay down the canonical project scaffold on a
+  box that has none. Instance startup uses the same additive initializer for the surrounding
+  `state`, `context`, `skills`, `topology`, and operational roots.
 - **`rig policy list` / `show` / `current`** *(v0.5.2)* — what permission policy is actually in
   effect: discovers custom policy specs, validates refs (malformed can never read as valid OR
   absent), shows what would apply.
@@ -374,20 +412,26 @@ your circumstances is configuration, and the ones that are not, another agent ca
   accounts, what the usage signals say, and whether a seat can be moved without stranding the
   conversation it is in the middle of. **`provider signals` reports anomalies rather than a
   listing** — unbound seats, accounts shared across several seats.
+- **Codex configuration fragments** — a `codex_config_fragment` must open with a table header and
+  never overrides a user-declared table; see `docs/reference/agent-spec.md`.
 - **`rig env`** — the real services behind a rig: are they up, what are they saying, how do you
   stop them without killing the rig.
 - **`rig setup`** — what OpenRig would change about this machine, shown before it touches anything.
 - **`rig usage series`** — what a seat's token curve has looked like over time: climbing steadily,
   reset, or stopped reporting entirely. The last one is a signal, not a gap.
 - **`rig tui`** — the interactive view over rigs, pods, seats and specs. **`rig tui commands`**
-  lists everything it can do without launching it. **`rig ui open`** is unmaintained, best-effort,
-  and replaced by the TUI, so never diagnose product behaviour from the web UI. The TUI plus Slack
-  are the human surface; the CLI plus terminal are the agent surface.
+  lists everything it can do without launching it. Open the instance row for one continuous
+  cross-rig agent table with pod separators and material `RECENT` transitions; drill into a rig,
+  mission, slice, or agent without losing the owning identity. **`rig ui open`** is unmaintained,
+  best-effort, and replaced by the TUI, so never diagnose product behaviour from the web UI. The
+  TUI plus Slack are the human surface; the CLI plus terminal are the agent surface.
 - **`rig mcp serve`** — how an agent that speaks MCP rather than shell drives OpenRig, and which
   operations are exposed that way. Relevant the moment a tool you are integrating cannot run a
   shell command.
-- **`rig skill`** — how packaged capability gets routed and projected to seats. Worth knowing the
-  layer exists; it is mid-repair right now, so treat what is currently installed as in flux.
+- **`rig skill loadout --runtime <claude-code|codex>`** — inspect the exact catalog revision,
+  selectors, target, and current/missing/shadowed/conflicting state for one working directory.
+  `--apply` writes only the managed ownership set, is idempotent, and refuses local edits or
+  unowned collisions.
 - **`rig startup-proof submit`** — prove you actually oriented at boot, rather than claiming you
   read the prompt.
 

package/daemon/context-packs/skills/agent-operated-software/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: agent-operated-software
+description: >-
+  Use when designing, building, operating, or diagnosing an ongoing application whose live backend
+  or control loop includes OpenRig agents, including applications with a Markdown, YAML, or JSON
+  agent control plane or a thin surface over specialist agent roles.
+metadata:
+  openrig:
+    stage: provisional
+    audience: any agent building or operating an agent-backed application
+    sibling_skills:
+      - agent-operated-workflows
+      - forming-an-openrig-mental-model
+      - mission-slice-sop
+      - openrig-user
+---
+
+# Agent-Operated Software
+
+**Agent-Operated Software** is an ongoing application whose functioning runtime includes an OpenRig
+agent or rig in its live backend or control loop. The application surface can be thin: structured
+state and specialist roles do the work, while the UI makes that work legible and steerable.
+
+## Start with the shared taxonomy
+
+- **AI-enabled software:** application code owns the control loop and calls a model as one capability.
+- **Agent-Operated Workflow:** an agent owns one bounded procedure with a start and stop condition;
+  see `agent-operated-workflows`.
+- **Agent-Operated Software:** agents participate in an ongoing application's functioning runtime.
+
+An application may compose many Agent-Operated Workflows. A bounded workflow does not by itself make
+its surrounding product Agent-Operated Software, and a model call is neither category unless an agent
+owns part of the control loop.
+
+## Agents are part of the backend
+
+In this architecture, behavior is not located only in functions. It is distributed across agents,
+skills, instructions, bootstrap files, schemas, Markdown, YAML, JSON, folders, and deterministic
+tools. A surprising result may therefore be a code defect or a coherence gap in this control plane.
+Trace the path that actually produced the behavior before choosing which layer to repair.
+
+This is not permission to tolerate defects in OpenRig core or another rock-solid substrate. There,
+reproduce the bug, fix the code, and hold the full gate. The faster coherence-first posture belongs
+to recoverable agent-operated application layers whose state and behavior can be inspected and
+repaired cheaply.
+
+## Markdown is the control plane
+
+Markdown is maximally useful to an agent while remaining legible enough for a human to steer. Put
+intent, work state, evidence, and decisions into stable addressed artifacts rather than private chat
+or an opaque custom database. Keep schemas and conventions aligned with the running behavior: the
+agent population acts on those files as executable context.
+
+Use **progressive disclosure**. A skill's name and description are the hot trigger; its body is cold
+procedure. Descriptions say when to load, not how to work. The body should route the reader to exact
+sources instead of copying them into another doctrine fork.
+
+Scripts can act as prompts. A good script returns the context or exact effect an agent needs; when it
+cannot, its failure teaches what it observed, why it stopped, and safe next actions. Keep deterministic
+mechanics in tools and judgment in agents.
+
+## Make artifacts self-certifying
+
+When a tool produces an artifact, do not make every consumer invent a completeness test:
+
+1. Write to a partial path, never the final path.
+2. Verify the property that can actually be wrong, such as duration, streams, resolution, or schema.
+3. Flush and atomically rename the partial artifact to its final path.
+4. Write the manifest, then a `.done` sentinel last.
+
+Consumers fail closed on the shared proof. A filename or exit code is not content verification.
+
+## Build with an agent SDLC
+
+Map work onto **intent -> plan -> spec -> build -> verify -> review -> QA -> done**. The human supplies
+steering, judgment, taste, and the call on irreversible ambiguity; agents perform and coordinate the
+technical work. Locks freeze the agreed spec and accepted delivery so multiple seats can work without
+guessing whether the target moved.
+
+For studio applications, the running product is usually the best iteration surface. A separate mockup
+earns its cost only when it resolves a real design uncertainty that the running app cannot expose as
+cheaply. This removes a redundant artifact, not the visual review or proof contract.
+
+## Repair the narrowest authoritative layer
+
+Find the generator or source that every affected agent actually consumes. Fix a code defect in code;
+fix a missing trigger in the skill; fix a malformed contract in its schema. Then verify through the
+consumer. Editing a rendered or installed copy creates a temporary fork, not a repair.
+
+The payoff compounds: a correction to the shared application control plane changes the next agent's
+starting point. That is how an ongoing agent-operated system improves without making one human its
+permanent router.

package/daemon/context-packs/skills/agent-operated-software/manifest.yaml

@@ -0,0 +1,10 @@
+# GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
+# Package-time projection of a canonical skill; regenerated every build.
+name: "agent-operated-software"
+version: "0.5.9"
+taxonomy: "skills"
+purpose: "Use when designing, building, operating, or diagnosing an ongoing application whose live backend or control loop includes OpenRig agents, including applications with a Markdown, YAML, or JSON agent control plane or a thin surface over specialist agent roles."
+files:
+  - path: "SKILL.md"
+    role: "instruction"
+    summary: "Use when designing, building, operating, or diagnosing an ongoing application whose live backend or control loop includes OpenRig agents, including applications with a Markdown, YAML, or JSON agent control plane or a thin surface over specialist agent roles."

package/daemon/context-packs/skills/agent-operated-workflows/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: agent-operated-workflows
+description: >-
+  Use when a bounded real-world procedure has a deterministic happy path but brownfield, variable,
+  or partially knowable state; when an operation must resume from verified evidence; or when deciding
+  whether agent judgment or ordinary code should own a procedure's control loop.
+metadata:
+  openrig:
+    stage: provisional
+    audience: any agent operating or designing a bounded procedure
+    sibling_skills:
+      - agent-operated-software
+      - openrig-user
+      - systematic-debugging
+---
+
+# Agent-Operated Workflows
+
+An **Agent-Operated Workflow** is a bounded procedure whose control loop belongs to an agent. The
+agent observes, interprets, sequences bounded actions, verifies their effects, adapts, and escalates
+genuine ambiguity. Deterministic code remains the exact substrate; it does not pretend to understand
+every state of a brownfield world.
+
+## Name the architecture before using it
+
+- **AI-enabled software:** application code owns the control loop and calls a model as one capability.
+- **Agent-Operated Workflow:** an agent owns one bounded procedure with a start and stop condition.
+- **Agent-Operated Software:** an OpenRig agent or rig participates in an ongoing application's live
+  backend or control loop. It may run many workflows; see `agent-operated-software`.
+
+Calling a model is not enough. A deterministic program that consults a model still owns its loop.
+
+## Decide whether the agent earns the loop
+
+Use an agent when the happy path is deterministic but the environment is brownfield, variable,
+partially knowable, or disproportionately expensive to model exhaustively. The judgment is in
+discovering what is true and choosing the next safe act.
+
+Prefer ordinary code when the state space is closed and code is simpler and more reliable than
+judgment. A parser, fixed data transformation, or fully enumerated state machine does not become
+better because an agent drives it.
+
+## Keep ownership explicit
+
+| Owner | Responsibility |
+|---|---|
+| Runbook | owns policy, the mental model, checkpoints, stop conditions, and escalation rules |
+| Deterministic tools | own context gathering and bounded exact actions |
+| Agent | owns interpretation, sequencing, adaptation, and effect verification |
+| Human | owns destructive ambiguity and product policy |
+
+The runbook guides judgment; tools enforce the invariants that must not be arguable.
+
+## Operate
+
+1. Establish identity, durable state, the runbook, and the promised outcome.
+2. Inspect with side-effect-free reads or an explicit plan mode.
+3. Choose one bounded action from observed state; do not mechanically replay the happy path.
+4. Verify the effect at the consumer or state surface that could prove it wrong.
+5. Record an observable checkpoint before moving on, so another agent can resume.
+6. Continue, stop at the declared condition, or escalate with evidence and the decision needed.
+
+An interrupted or timed-out mutation is **indeterminate**, never failed by assumption and never safe
+to retry blind. Where a compatibility period is safer, separate reversible preparation from the
+destructive finalizer. Idempotence is a claim to prove per action, not a label for the whole run.
+
+## Build
+
+Expose composable verbs, not an optimistic end-to-end controller. Help is inert. Read and plan modes
+are explicit. Mutations are narrow and independently readable. A failure should say what was
+observed, why the tool stopped, what remains unchanged, the safe next choices, and where its evidence
+lives. Keep checkpoints durable, effects observable, and recovery possible without private developer
+knowledge.
+
+A capability composition is a reusable recipe; this is the execution architecture that operates
+capabilities toward an outcome. Promote a proven workflow to the composition shelf only after use.
+
+**Reference implementation:** Release 0.5.9 Slice 05 is the first **Agent-Operated Migration**. Its
+runbook and helpers remain there; this skill carries the reusable contract, not a duplicate procedure.

package/daemon/context-packs/skills/agent-operated-workflows/manifest.yaml

@@ -0,0 +1,10 @@
+# GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
+# Package-time projection of a canonical skill; regenerated every build.
+name: "agent-operated-workflows"
+version: "0.5.9"
+taxonomy: "skills"
+purpose: "Use when a bounded real-world procedure has a deterministic happy path but brownfield, variable, or partially knowable state; when an operation must resume from verified evidence; or when deciding whether agent judgment or ordinary code should own a procedure's control loop."
+files:
+  - path: "SKILL.md"
+    role: "instruction"
+    summary: "Use when a bounded real-world procedure has a deterministic happy path but brownfield, variable, or partially knowable state; when an operation must resume from verified evidence; or when deciding whether agent judgment or ordinary code should own a procedure's control loop."

package/daemon/context-packs/skills/applying-a-permission-policy/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "applying-a-permission-policy"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when a permission policy is attached to a rig/seat (rig.yaml permission_policy:), or a user asks you to apply one, and you must translate that harness-neutral policy into the target harness's LIVE permission config — Claude settings.json / Codex config.toml / Pi run flags. Agent-driven and interactive: you read the policy, ground yourself in YOUR harness version, show the diff, and ask before writing. NOT for defining policies (that's the policy spec) and NOT a set-and-forget updater."
 files:

package/daemon/context-packs/skills/claude-compaction-restore/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "claude-compaction-restore"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when a Claude Code session has just compacted, is about to compact, reached context limit, resumed after /compact, or needs to rebuild its working mental model from Claude JSONL transcripts and touched files."
 files:

package/daemon/context-packs/skills/core/agent-starters/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "agent-starters"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when creating, refreshing, packaging, inspecting, promoting, or deprecating a named per-seat starting point — Agent Starter manifest authoring, the 6-state lifecycle (captured → named → inspectable → used → promoted → deprecated), provenance honesty, and refusal rules. NOT a VM image; a managed starting point composed from agent role + startup context + optional native session source + provenance."
 files:

package/daemon/context-packs/skills/core/agent-startup-and-context-ingestion/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "agent-startup-and-context-ingestion"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when designing or auditing how an agent becomes useful after launch — AGENTS.md overlays, role files, skills, rig specs, workflow specs, startup checklists, refocus messages, \"rig context\" surface. Covers the 4 failure modes that make startup context fail (old rig spec misses current operating mode; current agents never told about new guidance; startup file as dumping ground; orchestrator transmits implementation without preserving product intent)."
 files:

package/daemon/context-packs/skills/core/cross-host-rig-commands/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "cross-host-rig-commands"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when issuing `rig` commands against a remote host via `--host <id>` flag (single-hop SSH to a host declared in `~/.openrig/hosts.yaml`). Covers the 4 structured failure modes (ssh-unreachable / permission-gate / remote-daemon-unreachable / remote-command-failed), the `--verify` honest pass-through (SSH success is NOT verify success), and the host-registry shape. v0 supports `rig send / capture / ps / whoami --host <id>`."
 files:

package/daemon/context-packs/skills/core/human-in-the-loop/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "human-in-the-loop"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when classifying a slice closeout (auto-continue / human gate / park), routing a real decision to a human, or designing a human queue/dashboard surface. Treats humans as durable network participants with attention surfaces, queues, and decision records — escalation lands as a durable attention item, not a chat message. Approval is NOT required for every clean closeout; the default RSI conveyor continues unless an explicit human gate is reached."
 files:

package/daemon/context-packs/skills/core/messaging-the-human/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "messaging-the-human"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when a human decision, access grant, external action, or escalation must survive the operator's absence, or when an orchestrator or PM has a judgment-worthy update for the operator."
 files:

package/daemon/context-packs/skills/core/openrig-architect/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "openrig-architect"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when designing multi-agent topologies that run ON OpenRig — authoring RigSpec and AgentSpec files for new rigs, creating agent startup content (guidance / skills / culture), or diagnosing why a launched rig's agents aren't behaving as intended. NOT for changing OpenRig itself (use openrig-builder); NOT for ordinary CLI operation of an existing rig (use openrig-user). Covers the full authoring lifecycle from user intent to validated, launchable rig."
 files:

package/daemon/context-packs/skills/core/openrig-cmux/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "openrig-cmux"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when opening OpenRig fleet terminals into cmux — turning a rig, pod, mission, slice, or saved view into live agent tiles via `rig terminal --provider cmux`, or driving cmux on an agent's request. Same OpenRig view semantics as openrig-herdr (the verbs, honest-partial/degrade, read-only cross-rig, scroll/copy, same-size-only duplicates); cmux is the **best-effort** provider (herdr is the default and the proof-gated one). Prefer openrig-herdr unless cmux is specifically wanted."
 files:

package/daemon/context-packs/skills/core/openrig-herdr/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "openrig-herdr"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when opening OpenRig fleet terminals as a herdr wall — turning a rig, pod, mission, slice, or saved view into live interactive agent tiles via `rig terminal`, watching another rig read-only, or driving herdr on an agent's request (\"open all my rigs + a mission as views\"). Covers the `rig terminal open|views|status` verbs, the honest-partial/degrade reading of the result, the read-only-by-construction rail for cross-rig views, scroll/copy out of the box, and the same-size-only duplicate-pane "
 files:

package/daemon/context-packs/skills/core/openrig-skills/SKILL.md

@@ -13,7 +13,7 @@ You're running inside OpenRig. OpenRig ships a set of **skills** — small docum
 
 ## How OpenRig context works (30 seconds)
 
-Skills are **progressive disclosure**: a skill's *name + description* sit in your context ambiently (the "hot tier"); its *body* loads only when you open it. So you don't pre-read everything — you pattern-match a skill's "when" to your moment, then open just that one. This file is the index over the whole shipped set. (For the full model of building/operating agent software, open `software-for-agents`.)
+Skills are **progressive disclosure**: a skill's *name + description* sit in your context ambiently (the "hot tier"); its *body* loads only when you open it. So you don't pre-read everything — you pattern-match a skill's "when" to your moment, then open just that one. This file is the index over the whole shipped set. (For bounded procedures, open `agent-operated-workflows`; for ongoing agent-backed applications, open `agent-operated-software`.)
 
 Every row below names **how to reach the skill** — already-hot, or an exact load path. No row is a dead end.
 
@@ -63,7 +63,9 @@ These are auto-delivered to every rig; their name+description are already in you
 - **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.
+- **agent-operated-workflows** — a bounded real-world procedure needs an agent to interpret state and operate exact tools, or you are deciding whether ordinary code should own the loop.
+- **agent-operated-software** — you are designing or operating an ongoing application whose live backend includes OpenRig agents.
+- **software-for-agents** — compatibility redirect for the former `agent-operated-software` name; remove in 0.6.0.
 - **openrig-skills** — this index (you're reading it). Always loaded; the entry point to everything below.
 
 ### Load when your role or task calls for it (repo-shipped, profile-selected)

package/daemon/context-packs/skills/core/openrig-skills/manifest.yaml

@@ -1,7 +1,7 @@
 # GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
 # Package-time projection of a canonical skill; regenerated every build.
 name: "openrig-skills"
-version: "0.5.8"
+version: "0.5.9"
 taxonomy: "skills"
 purpose: "Use when you're operating OpenRig and need the right skill or context for fleet recovery, seat handover, new-seat orientation, a watchdog wake, cross-host reach to an agent on another machine, rig packaging, an OpenRig upgrade, systematic debugging, queue triage, or implementation planning; also use when you don't know what applies or nothing is projected on cold boot."
 files:

package/daemon/context-packs/skills/core/openrig-upgrade/SKILL.md

@@ -113,6 +113,87 @@ The helper never deletes a live file and never overwrites a local modification.
 Local deletions, live-only files, target removals, and ambiguous types are
 reported for the agent to resolve. Re-run the plan after any manual resolution.
 
+### Migrate a pre-0.5.9 instance layout
+
+Version 0.5.9 puts context-usage telemetry in
+`$OPENRIG_HOME/state/context-usage`, provider telemetry in
+`state/provider-usage`, the addressable library under `context/`, and the
+default System World at `context/system/system-world.yaml`. Existing 0.5.8
+homes cross that boundary through an **Agent-Operated Migration**: the target
+runtime reads canonical-first with legacy-fallback while all new writes use the
+canonical state roots. An explicitly configured custom context-library root
+stays stable throughout activation.
+
+The helper supplies bounded, inspectable operations. The agent owns their
+sequence and the target-runtime activation between them. With an exact
+protected preimage path, first inspect and then prepare canonical directories,
+the default System World, and a config pin to the existing library. Preparation
+does not copy telemetry, rewrite live collector settings, or run lifecycle
+actions:
+
+`--help` prints the phase grammar without inventorying the instance. With no
+phase flag the helper intentionally runs the read-only plan; unknown options
+fail nonzero before plan or mutation.
+
+```bash
+node "$SKILL_DIR/scripts/migrate-telemetry-state-0.5.9.mjs" --help
+
+node "$SKILL_DIR/scripts/migrate-telemetry-state-0.5.9.mjs" \
+  --home "$OPENRIG_HOME"
+
+node "$SKILL_DIR/scripts/migrate-telemetry-state-0.5.9.mjs" \
+  --home "$OPENRIG_HOME" \
+  --apply-state \
+  --preimage "$OPENRIG_HOME/backups/layout-0.5.9-before"
+```
+
+Activate the exact target runtime using the ordinary upgrade workflow. Then
+wait until every bounded post-apply legacy tail is followed by newer paired
+new-root samples for that same seat. This proves temporal convergence
+without blanket process replacement; a later legacy write remains a hard stop.
+Capture the verification JSON; copied old sidecars are not evidence:
+
+```bash
+node "$SKILL_DIR/scripts/migrate-telemetry-state-0.5.9.mjs" \
+  --home "$OPENRIG_HOME" \
+  --verify \
+  --preimage "$OPENRIG_HOME/backups/layout-0.5.9-before" \
+  > /safe/path/layout-0.5.9-verify.json
+```
+
+Only a successful receipt authorizes the separately invoked non-destructive
+finalizer. It copies an unconfigured legacy library into the canonical root
+without overwriting anything; a custom context-library root remains stable:
+
+```bash
+node "$SKILL_DIR/scripts/migrate-telemetry-state-0.5.9.mjs" \
+  --home "$OPENRIG_HOME" \
+  --apply-library \
+  --preimage "$OPENRIG_HOME/backups/layout-0.5.9-before" \
+  --verification /safe/path/layout-0.5.9-verify.json
+```
+
+Stop on every reported issue: malformed or foreign telemetry, a reserved-path
+conflict, a library collision, config drift, resumed legacy writes, byte drift,
+or a missing fresh dual sample all require the named repair before continuing.
+Verification binds the exact accepted tail bytes to their paired-newer samples;
+the finalizer revalidates them immediately before switching config. The helper
+never removes the legacy telemetry or library. Their later retirement is a
+separate agent decision after stable runtime, writer, reader, and recovery proof.
+It does not stop/start the daemon, launch a seat, touch the database, or decide
+whether the upgrade proceeds.
+
+To recover, restore the prior runtime as the agent-led workflow requires, then
+reverse only helper-owned config, System World, empty-directory, and copied
+library effects. Real state samples and both legacy recovery sources remain for
+inspection:
+
+```bash
+node "$SKILL_DIR/scripts/migrate-telemetry-state-0.5.9.mjs" \
+  --home "$OPENRIG_HOME" \
+  --rollback "$OPENRIG_HOME/backups/layout-0.5.9-before"
+```
+
 ## Agent-led continuity upgrade
 
 This is a decision guide, not a command recipe. Adapt paths and checks to the