@openrig/cli 0.6.14 → 0.7.0

package/README.md

@@ -26,9 +26,9 @@ use:
 
 ```sh
 # Claude Code
-npx skills add https://github.com/mvschwarz/openrig/tree/v0.6.14/skills/rigs --skill rigs --agent claude-code
+npx skills add https://github.com/mvschwarz/openrig/tree/v0.7.0/skills/rigs --skill rigs --agent claude-code
 # Codex
-npx skills add https://github.com/mvschwarz/openrig/tree/v0.6.14/skills/rigs --skill rigs --agent codex
+npx skills add https://github.com/mvschwarz/openrig/tree/v0.7.0/skills/rigs --skill rigs --agent codex
 ```
 
 Then type `/rigs` in Claude Code, or `$rigs` in Codex, and say what you want built. The skill has your agent tell
@@ -42,7 +42,7 @@ Already have OpenRig? Use the tag that matches `rig --version`, or upgrade first
 
 Prefer to type the commands yourself? [Install it yourself ↓](#install-it-yourself)
 
-Requires Node.js 22 or 24 and tmux, on macOS or Linux, and one working Claude Code or Codex account: one is enough, since the kernel operator adapts the shipped `starter` team to whichever you have. On Linux, the distribution's own Node.js can be older (Ubuntu 24.04's is 18); install a supported version with [nvm](https://github.com/nvm-sh/nvm) (`nvm install 22`) or NodeSource. On a Mac with Apple silicon, use Node.js 22 ([compatibility history](docs/releases/v0.5.15.md#known-compatibility-limitation)). On a Mac where you aren't an administrator, or where Homebrew belongs to another account (its `brew install` is refused), install Node.js in your own home folder with [nvm](https://github.com/nvm-sh/nvm): run `touch ~/.zshrc` (a new Mac account has none, and nvm's installer only adds itself to a profile file that already exists), then the install command on nvm's page, open a new terminal, and run `nvm install 22`. That needs no administrator password, and `npm install -g` then installs into your nvm folder. On Windows, use WSL2, the Windows route OpenRig supports; native Windows isn't supported. OpenRig's automated tests don't run on WSL2 yet; see [one user's working setup](docs/reference/getting-started.md#wsl2-a-reported-working-setup).
+Requires Node.js 22 or 24 and tmux, on macOS or Linux, and one working Claude Code or Codex account: one is enough, since the kernel operator adapts the shipped `starter` team to whichever you have. On Linux, the distribution's own Node.js can be older (Ubuntu 24.04's is 18); install a supported version with [nvm](https://github.com/nvm-sh/nvm) (`nvm install 22`) or NodeSource. On a Mac with Apple silicon, use Node.js 22 ([compatibility history](docs/releases/v0.5.15.md#known-compatibility-limitation)). On a Mac where you aren't an administrator, or where Homebrew belongs to another account (its `brew install` is refused), install Node.js in your own home folder with [nvm](https://github.com/nvm-sh/nvm): run `touch ~/.zshrc` (a new Mac account has none, and nvm's installer only adds itself to a profile file that already exists), then nvm's install command, for nvm v0.40.8 `curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.8/install.sh | bash` ([nvm's page](https://github.com/nvm-sh/nvm#install--update-script) has the newest), open a new terminal, and run `nvm install 22`. nvm itself needs no administrator password, and `npm install -g` then installs into your nvm folder. If nvm's installer says you need Apple's command line tools, run `xcode-select --install`, then its install command again. On Windows, use WSL2, the Windows route OpenRig supports; native Windows isn't supported. OpenRig's automated tests don't run on WSL2 yet; see [one user's working setup](docs/reference/getting-started.md#wsl2-a-reported-working-setup).
 
 > **What OpenRig changes on your machine**
 > - **Install:** `@openrig/cli` goes in globally with npm.
@@ -68,14 +68,14 @@ Requires Node.js 22 or 24 and tmux, on macOS or Linux, and one working Claude Co
 
 ### Install it yourself
 
-This runs OpenRig's install script from the `v0.6.14` release. It checks Node.js and npm, installs the latest published `@openrig/cli` with `npm install -g`, runs the Node.js and SQLite check, then runs `rig setup --dry-run` and `rig setup`. The first line prints that plan and changes nothing:
+This runs OpenRig's install script from the `v0.7.0` release. It checks Node.js and npm, installs the latest published `@openrig/cli` with `npm install -g`, runs the Node.js and SQLite check, then runs `rig setup --dry-run` and `rig setup`. The first line prints that plan and changes nothing:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.14/scripts/install.sh | sh -s -- --dry-run
-curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.14/scripts/install.sh | sh
+curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.7.0/scripts/install.sh | sh -s -- --dry-run
+curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.7.0/scripts/install.sh | sh
 ```
 
-If `rig setup` doesn't finish ready, for example because a provider isn't signed in yet, the script ends with `INSTALLED, SETUP NOT COMPLETE`: the CLI is installed, and `rig setup` lists what's left under "Some steps need attention". If the only items left are provider sign-ins, sign in to each selected provider as below and continue; run `rig setup` again rather than reinstalling the CLI.
+If a provider isn't signed in yet, the last step reports `FAILED [4/4]`, and `rig setup` lists the sign-in under "Some steps need attention". If the only remaining failures are provider sign-ins, the install steps finished; sign in to each selected provider as below and continue.
 
 **Or step by step:**
 
@@ -106,10 +106,11 @@ to an unused provider.
 ### Your agent opens OpenRig for you
 
 After installing, your agent opens the OpenRig TUI and the operator for you. To get back to them later, ask your
-agent for OpenRig or your agents in any words. After checking the selected login, it runs:
+agent for OpenRig or your agents in any words. After checking the selected login, it starts the daemon if it's stopped
+and opens the view:
 
 ```sh
-rig daemon start  # if stopped
+rig daemon start
 rig terminal open saved:kernel --window
 ```
 

package/daemon/assets/plugins/openrig-core/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "openrig-core",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "OpenRig canonical skills and hooks for cross-runtime agent topology coordination, continuity, and operating discipline.",
   "author": {
     "name": "Mike Schwarz",

package/daemon/assets/plugins/openrig-core/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "openrig-core",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "OpenRig canonical skills and hooks for cross-runtime agent topology coordination, continuity, and operating discipline.",
   "author": {
     "name": "Mike Schwarz",

package/daemon/assets/plugins/openrig-core/README.md

@@ -41,14 +41,21 @@ This plugin ships dual-manifest packaging — both `.claude-plugin/` and `.codex
   `CLAUDE_PROJECT_DIR` doesn't follow a `cd`. A Claude started in the seat's own project folder is the same project and
   still acts as the seat. A seat launched before this change has no `OPENRIG_SEAT_PROJECT_DIR` until its next launch, restore
   or handover, and behaves as before until then.
-- **Codex CLI** — Codex has no directory option for plugins, so it does not load this plugin. A Codex seat gets only the hooks
-  the daemon writes into Codex's `config.toml` (the activity relay); `hooks/codex.json` is not read.
+- **Codex CLI** — OpenRig installs the plugin automatically when a Codex seat selects it and hooks are enabled.
+  On the first installation, it trusts only the six exact shipped hook definitions, after checking installed hook files
+  and scripts against the daemon's packaged copy. Existing plugin disables and hook choices remain in place across
+  restart and upgrade. An existing untrusted plugin stays under native review: Codex does not persist "continue without
+  trusting", so an absent trust record on an existing installation is not treated as permission.
+  - **One activity producer:** the four managed inline hooks report Codex activity; the plugin's activity entries are
+    no-ops. The plugin supplies refocus and skills. Disabling an inline activity hook is not bypassed by the plugin.
+  - **Seat scope:** the commands require both `OPENRIG_SEAT_PROJECT_DIR` and the executable `OPENRIG_NODE`. Personal and
+    unselected sessions are no-ops. A nested Codex inheriting those seat variables still acts as that seat.
 
 Generated Claude settings commands for the activity relay and context collector use the daemon's absolute Node
 executable when its name is recognized (`node` or `node.exe`); other names keep the legacy bare `node` command and
 its PATH requirement. Pinned commands do not require Node on the Claude process's inherited PATH. The executable must
-remain installed; removing or moving it requires normal command refresh from a healthy runtime. This does not change the static plugin
-manifest commands, which still use `node`, or prove that an already-running Claude reloaded changed settings.
+remain installed; removing or moving it requires normal command refresh from a healthy runtime. This does not change the Claude plugin
+manifest's commands, which still use `node` (the Codex manifest's run `$OPENRIG_NODE`, above), or prove that an already-running Claude reloaded changed settings.
 
 One skill targets Claude Code's compaction behavior specifically:
 - `claude-compaction-restore` — used to rebuild a Claude Code agent's working mental model after `/compact`, from JSONL transcripts and touched files

package/daemon/assets/plugins/openrig-core/hooks/codex.json

@@ -5,7 +5,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\"",
+            "command": "test -n \"$OPENRIG_SEAT_PROJECT_DIR\" && test -f \"$OPENRIG_NODE\" && test -x \"$OPENRIG_NODE\" || exit 0; exec \"$OPENRIG_NODE\" \"${PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\" --from-plugin",
             "timeout": 5
           }
         ]
@@ -16,7 +16,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\"",
+            "command": "test -n \"$OPENRIG_SEAT_PROJECT_DIR\" && test -f \"$OPENRIG_NODE\" && test -x \"$OPENRIG_NODE\" || exit 0; exec \"$OPENRIG_NODE\" \"${PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\" --from-plugin",
             "timeout": 5
           }
         ]
@@ -25,7 +25,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/refocus.cjs\" --runtime codex",
+            "command": "test -n \"$OPENRIG_SEAT_PROJECT_DIR\" && test -f \"$OPENRIG_NODE\" && test -x \"$OPENRIG_NODE\" || exit 0; exec \"$OPENRIG_NODE\" \"${PLUGIN_ROOT}/hooks/scripts/refocus.cjs\" --runtime codex",
             "timeout": 60
           }
         ]
@@ -36,7 +36,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\"",
+            "command": "test -n \"$OPENRIG_SEAT_PROJECT_DIR\" && test -f \"$OPENRIG_NODE\" && test -x \"$OPENRIG_NODE\" || exit 0; exec \"$OPENRIG_NODE\" \"${PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\" --from-plugin",
             "timeout": 5
           }
         ]
@@ -47,7 +47,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/refocus.cjs\" --runtime codex",
+            "command": "test -n \"$OPENRIG_SEAT_PROJECT_DIR\" && test -f \"$OPENRIG_NODE\" && test -x \"$OPENRIG_NODE\" || exit 0; exec \"$OPENRIG_NODE\" \"${PLUGIN_ROOT}/hooks/scripts/refocus.cjs\" --runtime codex",
             "timeout": 60
           }
         ]
@@ -58,7 +58,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\"",
+            "command": "test -n \"$OPENRIG_SEAT_PROJECT_DIR\" && test -f \"$OPENRIG_NODE\" && test -x \"$OPENRIG_NODE\" || exit 0; exec \"$OPENRIG_NODE\" \"${PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\" --from-plugin",
             "timeout": 5
           }
         ]

package/daemon/assets/plugins/openrig-core/hooks/scripts/activity-relay.cjs

@@ -46,7 +46,9 @@ function firstString(...values) {
   return null;
 }
 
-function buildOpenRigPayload(providerPayload, env = process.env, now = () => new Date()) {
+// The route this run reports by, so the daemon can count one event once per route: "plugin" for the plugin's hook
+// (started with --from-plugin), "managed" for the settings or managed hook copy.
+function buildOpenRigPayload(providerPayload, env = process.env, now = () => new Date(), argv = process.argv) {
   const sessionName = firstString(env.OPENRIG_SESSION_NAME, env.RIGGED_SESSION_NAME);
   const nodeId = firstString(env.OPENRIG_NODE_ID, env.RIGGED_NODE_ID);
   const runtime = firstString(env.OPENRIG_RUNTIME, env.RIGGED_RUNTIME);
@@ -80,6 +82,7 @@ function buildOpenRigPayload(providerPayload, env = process.env, now = () => new
     subtype,
     turnId: firstString(providerPayload.turn_id, providerPayload.turnId),
     occurredAt: now().toISOString(),
+    relayRoute: argv.includes("--from-plugin") ? "plugin" : "managed",
   };
 }
 
@@ -170,6 +173,10 @@ function buildSessionIdentityPayload(providerPayload, env = process.env, now = (
 
   if ((!sessionName && !nodeId) || !runtime) return null;
 
+  // #1524 (a): whether the runtime sent transcript_path, and its raw value. Codex sends an explicit null for a
+  // thread it never persists; the daemon tells that apart from an absent key, an empty string or a malformed value.
+  const transcriptPathPresent = Object.prototype.hasOwnProperty.call(providerPayload, "transcript_path");
+
   return {
     eventFamily: "session_identity",
     sessionName,
@@ -182,6 +189,8 @@ function buildSessionIdentityPayload(providerPayload, env = process.env, now = (
     // The daemon finds the Claude that ran this hook from its parent chain.
     hookPid: process.pid,
     sessionId,
+    transcriptPathPresent,
+    ...(transcriptPathPresent ? { transcriptPath: providerPayload.transcript_path } : {}),
     occurredAt: now().toISOString(),
   };
 }
@@ -268,6 +277,9 @@ function settingsRelayReports(hookEvent, providerPayload, env = process.env) {
 function pluginRunIsRedundant(providerPayload, argv = process.argv, env = process.env) {
   if (!argv.includes("--from-plugin")) return false;
   const hookEvent = firstString(providerPayload.hookEvent, providerPayload.hookEventName, providerPayload.hook_event_name, providerPayload.event, providerPayload.eventName);
+  // Codex activity has one producer: OpenRig's managed inline hooks. The plugin supplies refocus and skills, but its
+  // activity entries are no-ops. Do not infer merged native hook state here or bypass a person's inline-hook disable.
+  if (firstString(env.OPENRIG_RUNTIME, env.RIGGED_RUNTIME) === "codex") return true;
   return settingsRelayReports(hookEvent, providerPayload, env);
 }
 

package/daemon/assets/plugins/openrig-core/hooks/scripts/codex-hook-trust.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+// Codex's hook trust identity: the key and hash Codex records for a hook it has trusted.
+//
+// The recipe reproduces Codex's (codex-rs hooks/src/engine/discovery.rs hook_hash at rust-v0.163.0): the normalized
+// identity { event_name: <snake_case label>, matcher?, hooks: [<normalized handler>] }, with absent fields dropped, keys
+// sorted recursively, compact JSON, then "sha256:" + hex. The daemon's trust writer for its own managed activity hooks uses
+// it (codex-runtime-adapter.ts, computeCodexHookTrust). It needs no packages.
+
+const crypto = require("node:crypto");
+
+const EVENT_LABELS = {
+  SessionStart: "session_start",
+  UserPromptSubmit: "user_prompt_submit",
+  Stop: "stop",
+  PostCompact: "post_compact",
+  PermissionRequest: "permission_request",
+};
+
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) out[key] = sortKeys(value[key]);
+    return out;
+  }
+  return value;
+}
+
+/** Codex's trust hash for one command handler, from every field Codex folds into it. */
+function codexHookHash(eventLabel, handler) {
+  const normalized = { type: "command", command: handler.command, timeout: handler.timeoutSec, async: handler.async === true };
+  if (handler.statusMessage != null) normalized.statusMessage = handler.statusMessage;
+  if (handler.additionalContextLimit != null) normalized.additionalContextLimit = handler.additionalContextLimit;
+  const identity = { event_name: eventLabel, hooks: [normalized] };
+  if (handler.matcher != null) identity.matcher = handler.matcher;
+  const hex = crypto.createHash("sha256").update(JSON.stringify(sortKeys(identity)), "utf8").digest("hex");
+  return `sha256:${hex}`;
+}
+
+/** Codex's persisted trust key and hash for one hook, at its position in the config layer. */
+function computeCodexHookTrust(event, input) {
+  const label = EVENT_LABELS[event];
+  if (!label) throw new Error(`no Codex hook label for ${event}`);
+  const key = `${input.keySource}:${label}:${input.groupIndex ?? 0}:${input.handlerIndex ?? 0}`;
+  return { key, hash: codexHookHash(label, input) };
+}
+
+module.exports = { EVENT_LABELS, codexHookHash, computeCodexHookTrust };

package/daemon/assets/plugins/openrig-core/hooks/scripts/refocus.cjs

@@ -17,6 +17,8 @@ const DEFAULT_THRESHOLD = 2_600_000;
 const FALSE_VALUES = new Set(["0", "false", "off", "no"]);
 // The issue report after a failed attempt gets this long once the attempt's lookups are done.
 const REPORT_MS = 1_500;
+// A failed attempt's reason, kept for the retry's label. The attempt's own TRACE GAP line keeps the full text.
+const PENDING_FAILURE_MAX = 300;
 // The hook's time budget. Both registrations allow this hook 60 s (hooks/claude.json, hooks/codex.json). With no budget
 // selected, every lookup keeps its fixed 2 s cap exactly as before. OPENRIG_REFOCUS_BUDGET_MS selects a longer one, up
 // to 52 s: each lookup's cap then scales with it and every lookup is also clipped to what's left of it, so a slow lookup
@@ -286,15 +288,17 @@ function renderTrace() {
       timeout,
       maxBuffer: 16 * 1024 * 1024,
     });
-  const reason = result.error?.message || result.stderr?.trim() || `trace exited ${result.status ?? "without a status"}`;
+  const reason = String(result.error?.message || result.stderr?.trim() || `trace exited ${result.status ?? "without a status"}`)
+    .replace(/\s+/g, " ").trim();
   const failed = Boolean(result.error) || result.status !== 0 || !result.stdout?.trim();
   const trace = [
-    ...(failed ? [`TRACE GAP — ${String(reason).replace(/\s+/g, " ").trim()}`] : []),
+    ...(failed ? [`TRACE GAP — ${reason}`] : []),
     result.stdout?.trim(),
   ].filter(Boolean).join("\n");
   return {
     text: [trace, role].filter(Boolean).join("\n\n"),
     failed,
+    failure: failed ? `trace gap: ${reason}` : null,
   };
 }
 
@@ -334,8 +338,14 @@ function runsForThisSeatsProject(env = process.env) {
   const rawPrompt = typeof input.prompt === "string" ? input.prompt.trim() : "";
   // Claude can wrap a complete submitted message as pasted content. Unwrap only
   // that envelope; a peer quoting a restore request is still an ordinary prompt.
-  const prompt = harness === "claude"
-    ? (rawPrompt.match(/^<pasted_content id="([^"]+)">\s*([\s\S]*)\s*<\/pasted_content id="\1">$/)?.[2]?.trim() ?? rawPrompt)
+  // Check the delimiters separately: overlapping whitespace/wildcard matches can
+  // backtrack excessively on an incomplete paste or text after the closing tag.
+  const opening = harness === "claude" ? rawPrompt.match(/^<pasted_content id="([^"]+)">/) : null;
+  const closing = opening ? `</pasted_content id="${opening[1]}">` : "";
+  const prompt = opening
+    && rawPrompt.length >= opening[0].length + closing.length
+    && rawPrompt.endsWith(closing)
+    ? rawPrompt.slice(opening[0].length, -closing.length).trim()
     : rawPrompt;
   if (event === "UserPromptSubmit" && prompt.startsWith("OpenRig post-compaction turn boundary.")) process.exit(0);
 
@@ -429,6 +439,7 @@ function runsForThisSeatsProject(env = process.env) {
     if (state.pendingOn !== "PostCompact") {
       delete state.pendingOn;
       delete state.pendingAt;
+      delete state.pendingFailure;
     }
     state.lastReset = { at: new Date().toISOString(), fromBytes: Number(state.lastBytes || 0), toBytes: size };
     state.lastBytes = size;
@@ -463,6 +474,8 @@ function runsForThisSeatsProject(env = process.env) {
       if (state.managedRestorePending) state.managedRestorePendingAt = new Date().toISOString();
       else delete state.managedRestorePendingAt;
     }
+    // A new compaction is a fresh obligation, not a retry of the refocus before it.
+    if (event === "PostCompact") delete state.pendingFailure;
     if (event === "PostCompact" || !state.pendingOn) state.pendingOn = event;
     state.pendingAt ||= new Date().toISOString();
     persist();
@@ -487,10 +500,13 @@ function runsForThisSeatsProject(env = process.env) {
   const trace = rendered.text;
   const configured = readConfiguredContent(home);
   const failed = rendered.failed || Boolean(configured.failure);
+  // A post-compaction refocus still pending after a failed attempt is a retry of it, not a second compaction.
   const why = onDemand
     ? "on demand"
     : state.pendingOn === "PostCompact"
-      ? "just compacted — your picture is lossy"
+      ? state.pendingFailure
+        ? `retrying the post-compaction refocus; the last attempt failed: ${state.pendingFailure}`
+        : "just compacted — your picture is lossy"
       : `${Math.round(grown / 1e6 * 10) / 10}MB of work since your last refocus`;
 
   const body = configured.failure
@@ -541,6 +557,10 @@ function runsForThisSeatsProject(env = process.env) {
     if (failed || error) {
       state.pendingOn ||= event;
       state.pendingAt ||= new Date().toISOString();
+      const failure = rendered.failure
+        || (configured.failure ? `content ref ${configured.contentRef}: ${configured.failure}` : null)
+        || `the refocus could not be written: ${String(error?.message ?? error).replace(/\s+/g, " ").trim()}`;
+      state.pendingFailure = failure.length > PENDING_FAILURE_MAX ? `${failure.slice(0, PENDING_FAILURE_MAX - 1)}…` : failure;
       persist();
       return;
     }
@@ -549,6 +569,7 @@ function runsForThisSeatsProject(env = process.env) {
     state.firedOn = event;
     delete state.pendingOn;
     delete state.pendingAt;
+    delete state.pendingFailure;
     persist();
   });
 })();

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

@@ -221,12 +221,19 @@ The audit message asks for a read-depth table and tells you not to conserve toke
 
 The next restore map links this note, which keeps the chain unbroken.
 
+## Then resume
+
+Resume the outcome selected by the user's current instructions, standing duties and assigned work. Use existing
+task records, decisions and your recap to recover the next useful action, remaining constraints and evidence
+already earned. Check uncertain effects before replaying work. Available skills and historical suggestions do not
+by themselves widen scope or create required stages. Use authorized skills, subagents, peer help and useful tests
+within your remit without another permission request. Route a missing decision to its existing owner and continue
+unaffected work.
+
 ## Guardrails
 
 - Compaction is survival, not housekeeping. Compact only when a seat is genuinely near its limit, never to
   "lean" a seat or prepare a starter image; a compacted seat can sound confident while missing the context it needs.
-- Continue from the map and the files, not from the summary's "next step" alone: a hold placed after the
-  summary was written still binds.
 - Do not launch a fresh session in place of restoring.
 - An honest `PARTIAL` with its reason is a correct outcome. Claiming coverage you did not reach is the
   failure.

package/daemon/assets/plugins/openrig-core/skills/forming-an-openrig-mental-model/SKILL.md

@@ -242,8 +242,9 @@ If you're booting into a new seat in an OpenRig rig:
 4. **Check what skills you have** — list `.claude/skills/` or
    `.agents/skills/` in your cwd. Each skill has a frontmatter description
    that tells you when to reach for it.
-5. **Check your peers** — `rig capture <peer-session>` to see what they're
-   doing.
+5. **Check your peers** — `rig ps --nodes` and the queue first (who is up,
+   who holds what). Capture a peer (`rig capture <peer-session>`) only when
+   you actually need to see its screen.
 6. **Check the transcripts** if you're returning to an in-flight workstream
    — `rig transcript <session> --tail 100` for recent context.
 7. **Ask `rig ask <rig> "<question>"`** if you need cross-cutting evidence

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

@@ -5,6 +5,8 @@ metadata:
   cli_surfaces_referenced:
     - gateway human list
     - gateway human show
+    - gateway human mode room
+    - gateway human mode decide
     - queue create
     - queue transitions
     - queue block
@@ -69,6 +71,28 @@ rig queue create --destination <entityId>@external \
   --evidence-ref <durable-evidence> --verify --json
 ```
 
+Before asking a **decision**, check whether the person has a mode on with a
+decision room: what they said the team may decide for them meanwhile.
+
+```bash
+rig gateway human mode room <entityId>
+```
+
+If it names a room and your decision is plainly inside their words (and none of
+their exclusions), decide instead of waiting. Create the ask as above, then
+record your choice on it straight away:
+
+```bash
+rig gateway human mode decide <qitem-id> --application <applicationId> \
+  --choose <question>=<option> --reason "<why>" --reversible   # or --irreversible
+```
+
+It's recorded as decided on their behalf, never as their answer, the ask
+closes, and it's in their account when they're back. Say honestly whether it
+can be undone. A permission prompt or an approval is never decided this way.
+With no room, a room that doesn't plainly cover it, or any doubt, ask and wait;
+a recommended option is not a decision.
+
 An optional `--human-detail-file <path>` supplies one coherent supplemental
 reply in the same thread. Announce its purpose in the brief; the product also
 marks that a detail reply follows. The primary must already contain the complete

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

@@ -91,7 +91,7 @@ These ship in the OpenRig repo and reach a seat when its profile selects them. T
 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.
+- **review-team** — you're reviewing: fresh scrutiny, anti-slop, grounded findings.
 - **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):
@@ -106,7 +106,7 @@ Product-management craft (load when shaping/reviewing work):
 ### Vendored craft — load when you're coding (ships with upstream provenance)
 General engineering skills OpenRig ships as vendored copies. Open when the task matches; they carry "modified by OpenRig" provenance.
 
-- **verification-before-completion** — about to claim done / passing / fixed: run the check and read the output first.
+- **verification-before-completion** — about to claim done / passing / fixed: have evidence that applies to the candidate you name first.
 - **systematic-debugging** — debugging: find the root cause before the fix.
 - **agent-browser** — driving a browser (screenshot / screencast) from an agent.
 - **frontend-design** — designing frontend / UI.

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

@@ -90,6 +90,23 @@ rig queue handoff <qitem-id> \
   --body-file /tmp/import-report-handoff.md
 ```
 
+### After a queue write — use the response; read back only when it doesn't show what you need
+
+A queue write (`create`, `claim`, `update`, `handoff`, `handoff-and-complete`) answers with the row it wrote; a
+handoff answers with the closed row and its successor. When that answer shows what you need to establish, use it.
+Read back (`rig queue show <id> --full --json`, or `rig queue transitions <id>`) when it doesn't, for example:
+
+- the outcome was INDETERMINATE (a transport failure, or a 502 `remote_queue_write_failed`), or the write warned
+  `qitem_body_not_saved` (an existing row came back). Reconcile by the original ID before any retry;
+- the output was compact or truncated and the field you need isn't in it (the compact receipt shows `bodyBytes`, not
+  the body, and its footer names what it left out);
+- you need a transition note, a closure or blocker detail, or a successor that the output you saw omits;
+- you need evidence from downstream of the write: the recipient's wake (`create --verify` waits for it), or its
+  pickup or claim (a later read);
+- your team's custody rule asks for a separate read-back.
+
+Don't read back only to see again a field the response already showed you.
+
 ### §1b doctrine — turn ends by passing the ball
 
 **A turn ends by passing the ball, never by going idle holding the slice waiting
@@ -956,12 +973,7 @@ rig auth seats … --runtime codex         # seat -> profile registry (metadata
 
 ### Manage subscriptions across a fleet (when the person asks you to)
 
-**This applies only when both hold:**
-- the daemon's `provider.subscription_moves` setting is on. It's off by default; the person turns it on with
-  `rig config set provider.subscription_moves true`;
-- the person has asked you to manage their subscriptions.
-
-Otherwise, don't take this job on. Installing or upgrading OpenRig appoints no agent, launches no bundle and starts no
+**This applies only when the person has asked you to manage their subscriptions.** Otherwise, don't take this job on. Installing or upgrading OpenRig appoints no agent, launches no bundle and starts no
 rotation.
 
 When a person runs several Claude and Codex subscriptions across machines, the fleet studio bundle's one agent is meant
@@ -969,19 +981,19 @@ to keep work running, through the Fleet app. Until that bundle is available, the
 subscriptions can use this section. If that's you, you decide which subscription or home moves, and when. You decide
 from:
 - the usage and assignment readings, and their freshness;
-- the move record;
+- your earlier move reports;
 - the person's standing preferences.
 
 You say why, and you see the outcome through. OpenRig gives you the facts and the tools; it never decides for you,
 and there's no threshold to obey.
 
 **Who decides:**
-- **The person's operator agent** can ask you for a move, or look at the record. It doesn't make competing moves of
+- **The person's operator agent** can ask you for a move, or ask what you've moved. It doesn't make competing moves of
   its own.
 - **One agent manages subscriptions:** the one the person asked, or the fleet studio's agent once that bundle is
   available. There's no other fleet-manager role and no automatic manager. Use the commands below directly; no extra
   hand-off is needed.
-- **The Observatory is optional:** it can show your moves and readings, but you don't need it to rotate.
+- **The Observatory is optional:** it can show readings, but you don't need it to rotate.
 
 **The unit is a Codex home, with every seat on it.** Moving some seats on a shared home to a different account, and
 moving Claude seats, aren't supported moves yet: say so instead of improvising.
@@ -1013,8 +1025,7 @@ moving Claude seats, aren't supported moves yet: say so instead of improvising.
      --expect-account <the target's Account line>`. `--verify` only checks; it never restarts. Only that check
      reports `moved`, and anything less is unconfirmed.
    - **A slow reply isn't a failure:** never restart a seat a second time. Follow up at your next look.
-5. **Record every move, partial or unconfirmed included,** with `rig provider moves record --file <move.json>`
-   (`--help` shows the shape):
+5. **Report every move, partial or unconfirmed included,** to whoever asked for it (a queue item to their seat):
    - the home and machine;
    - from and to, as labels;
    - your reason;
@@ -1022,10 +1033,8 @@ moving Claude seats, aren't supported moves yet: say so instead of improvising.
    - each seat's result (`moved`, `unconfirmed` or `unknown`) with its evidence or what's missing;
    - the peers, for example "not restarted; account unverified".
 
-   A seat marked `moved` needs its `evidence`, and an `unconfirmed` or `unknown` one needs what's `missing`. A home
-   switched with every seat left as a peer is still a move to record, with `seats: []`. A follow-up that confirms an
-   earlier unconfirmed seat records a new move with `supersedes`. Asked "why did this
-   seat move?", answer from `rig provider moves --seat <seat>`. Never put credentials in a record.
+   A home switched with every seat left as a peer is still a move to report. A follow-up that confirms an earlier
+   unconfirmed seat says which report it follows. Never put credentials in a report.
 6. **When a sign-in is needed:**
    - Ask the person once, durably: a queue item to their seat, naming the machine and the subscription.
    - Move nothing onto that subscription until it's done.
@@ -1393,9 +1402,10 @@ or `rig add` (one member) when a seat needs an explicit model, a permission poli
 different agent spec or role profile, per-seat runtime or cwd, or startup files.
 
 Node-granular managed partial restore (v0.3.4+):
-- `rig launch <rig> <nodeRef>` relaunches a single seat by logical id or node id through orchestration. `<rig>` is the
-  rig's name or ID; a name shared by more than one active rig stops with the candidate IDs.
-- `rig launch <rig> --seats <a,b,c>` relaunches a comma-separated subset of seats.
+- `rig launch <rig> <nodeRef>` launches a single seat that isn't running, by logical id or node id, through orchestration.
+  `<rig>` is the rig's name or ID; a name shared by more than one active rig stops with the candidate IDs. A seat that's
+  already running is left as it is; for a fresh occupant there, use `rig seat launch <seat> --fresh --stop --reason <why>`.
+- `rig launch <rig> --seats <a,b,c>` launches a comma-separated subset of seats.
 - `--hold-reason <text>` records a reason for holding non-target seats during the partial launch.
 - This is a SUPPORTED managed path. The prior `pod_aware_launch_unsupported` dead-end is retired; pod-aware narrow launch now goes through this surface rather than ad-hoc rebuilds.
 

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

@@ -29,8 +29,9 @@ without an owner.
   with the rig appearing dormant.
 - **Finishing a slice that has a clear next step.** Default-nudge:
   receiver gets a wake-ping plus the durable queue item.
-- **Blocked on another agent's work.** Park the qitem with
-  `closure_reason: blocked_on` and the blocker qitem id.
+- **Blocked on another agent's work.** Use `rig queue block <id> --on <child>`
+  (or `rig queue update <id> --state blocked --blocked-on <child>`). The item
+  stays active and returns to pending when its blocker completes.
 - **Escalating to the human.** Make the escalation a durable attention
   item, not just a chat message.
 
@@ -53,16 +54,20 @@ human. The qitem state machine enforces this:
 `pending → in-progress → done` requires `closure_reason` from one of:
 
 - `handed_off_to` — work continues at a different seat (target = new owner)
-- `blocked_on` — parked pending another qitem (target = blocker qitem id)
 - `denied` — receiver rejected the work
 - `canceled` — sender or receiver withdrew
 - `no-follow-on` — terminal completion, nothing else needed
 - `escalation` — kicked up to a higher tier (target = escalation target)
+- `superseded` — replaced by another qitem (target = successor qitem id)
 
-Three of those (`handed_off_to`, `blocked_on`, `escalation`) additionally
+Two of those (`handed_off_to`, `escalation`) additionally
 require `closure_target`. The daemon enforces this at the domain layer;
 every surface (CLI, MCP, future UI) inherits the same guarantee.
 
+`done` is terminal. `closure_reason: blocked_on` is valid only on an active
+`state=blocked` park record, as used by workflow writers; combining it with
+`state=done` is rejected. Use the block command above to wait on another qitem.
+
 **The drafted-park failure (draft ≠ throw).** The rule is about the *actual* pass, not the
 intention to pass. A turn that ends with a self-instruction **typed into your own prompt but left
 unsent** — a drafted go-ahead, a next-atom note you never sent — has **not** handed off; it has
@@ -120,6 +125,7 @@ inverted the default-nudge polarity.
 - **Scope tags `project:<id>`, `mission:<id>`, `slice:<id>`** on project work, set when you create the row (`--tags`; `create` also takes `--mission` and `--slice`). Tags can't be edited afterwards. A handoff keeps the source row's tags unless you pass `--tags` or `--gate`, either of which replaces them; repeat the scope tags in `--tags` when you use `--gate`.
 - **Pass work on with `handoff-and-complete`.** It closes your row as done and records the next row as its successor in one step. A `create` followed by `update --state done --closure-reason handed_off_to` records no successor, and the stuck sweep raises a recovery item for it.
 - **Close what you hold.** A row you claimed ends in a handoff or an `update --state done --closure-reason …`; `rig queue overdue` lists claimed rows past their deadline.
+- **Use the write's response.** Read the row back only when the response doesn't show what you need (an indeterminate outcome, a field the compact output left out, downstream wake or pickup, a team custody rule): openrig-user, "After a queue write".
 - **Brief for the model that will read it.** Before handing a peer open-ended work, check which model it runs: `delegating-work`, "Check what kind of agent you're handing it to".
 
 ## Queue-body hygiene (token + parse safety)