@openrig/cli 0.6.12 → 0.6.13

package/README.md

@@ -20,16 +20,16 @@ Not setting this up today? Get the next walkthrough and occasional OpenRig updat
 
 ## Install and first run
 
-Requires Node.js 22 or 24 and tmux, on macOS or Linux. 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 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). Launching a rig writes provider hooks and workspace trust settings. Before running the commands below, read [what OpenRig changes on your machine](#what-openrig-changes-on-your-machine) and back up the relevant files.
+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). Launching a rig writes provider hooks and workspace trust settings. Before running the commands below, read [what OpenRig changes on your machine](#what-openrig-changes-on-your-machine) and back up the relevant files.
 
-**One command.** This runs OpenRig's install script from the `v0.6.12` 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:
+**One command.** This runs OpenRig's install script from the `v0.6.13` 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.12/scripts/install.sh | sh -s -- --dry-run
-curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.12/scripts/install.sh | sh
+curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.13/scripts/install.sh | sh -s -- --dry-run
+curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.13/scripts/install.sh | sh
 ```
 
-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.
+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.
 
 **Or step by step:**
 
@@ -161,7 +161,7 @@ using a published package, since repository guidance can be ahead of npm.
 | --- | --- |
 | **npm installation** | Installs the CLI (`rig` and `openrig-tui`), bundled components and dependencies under your npm prefix (with Bun, under Bun's global directory). OpenRig's postinstall checks the Node.js version and that the SQLite module loads; Bun may block this script. It does not run daemon or provider setup. |
 | **`rig setup`** | Attempts missing tools and writes an OpenRig block in `~/.tmux.conf` for mouse support and scrollback. Installs herdr by default on macOS and Linux unless declined with `--no-herdr`; an unavailable herdr install is a warning. On macOS the installing agent offers Ghostty, and `--ghostty` attempts it after acceptance. Existing cmux settings are left unchanged. `--full` adds workstation tools. `--dry-run` shows setup's plan without applying it. |
-| **Daemon startup** | Creates/updates instance state under `OPENRIG_HOME` (normally `~/.openrig`), including its database and managed plugin resources. Seeds the `openrig-skills` discovery skill, the `refocusing` skill and the person-facing `rigs` skill in `~/.claude/skills` and `~/.agents/skills`, subject to existing version ownership. With `runtime.codex.hooks_enabled` enabled (the default), writes Codex hook configuration and trust records as described below—even before a rig launches. |
+| **Daemon startup** | Creates/updates instance state under `OPENRIG_HOME` (normally `~/.openrig`), including its database and managed plugin resources. Seeds the `openrig-skills` discovery skill, the `refocusing` skill and the person-facing `rigs` skill in `~/.claude/skills` and `~/.agents/skills`, subject to existing version ownership. When a Codex seat is already recorded and `runtime.codex.hooks_enabled` is enabled (the default), ensures its hook configuration and trust records as described below. With no recorded Codex seat, enabled hooks wait for its first launch; disabled hooks still remove a stale OpenRig-managed hook block, if present. |
 | **Rig/seat launch and attachment** | Creates tmux sessions, supplies seat identity and daemon connection environment, and projects selected guidance, skills, plugins and runtime resources into the workspace. Managed startup pre-trusts the workspace. Claude context collection can also be provisioned for attached sessions and refreshed during monitoring. In a Git repository, newly created files under `.codex/plugins/shared:openrig-core/` (or the unqualified `.codex/plugins/openrig-core/`) are added to the repository's Git `info/exclude` inside an `# BEGIN OpenRig generated files` block; new `AGENTS.md`, `CLAUDE.md` and `CLAUDE.local.md` files stay visible with a warning. |
 | **Bundle install** (`rig bundle install`, or `rig up` with a `.rigbundle` or GitHub link) | Writes the bundle's files into the install target: `--target`, or the current directory for `rig up` and for a GitHub link. `rig bundle install` with a local archive needs `--target`. Routes its declared skills, plugins and context packs into your libraries. A GitHub link's archive is kept under `OPENRIG_HOME/bundle-imports/`, and installs are recorded in `OPENRIG_HOME/bundle-audit.jsonl`. A bundle that carries a project creates it under `workspace.projects_root` and records it, with the rig's association, in the workspace catalog. |
 | **Explicit permission configuration** | The built-in bootstrap does **not** add `rig` command allow rules to your settings files; a team seat with no permission policy, per-seat choice or (for Codex) named profile gets the per-launch [team default](docs/reference/rig-spec.md#team-launch-defaults) instead. Agent-guided setup recommends keeping it and requires your actual answer before the agent [adds remembered rules at your chosen scope](docs/reference/getting-started.md#have-your-agent-configure-permissions). No/no answer keeps the team default and preserves settings; existing choices and stricter rules remain relevant. Broader access is separate. |
@@ -175,7 +175,9 @@ user's home; changing `OPENRIG_HOME` alone does not isolate provider configurati
   writes `HOME/.claude.json`, and also `<CLAUDE_CONFIG_DIR>/.claude.json` when the
   daemon has that variable set. In the workspace, `.claude/settings.local.json` receives
   the context collector's `statusLine` command and selected activity hooks;
-  the collector script lives under `.openrig/`, and the activity-hook relay under
+  a user's own status-line command is preserved, so it can prevent collector
+  installation. Selected settings resources can still replace overlapping keys.
+  The collector script lives under `.openrig/`, and the activity-hook relay under
   the instance's `state/claude-activity-hooks/`. Selected settings/MCP resources can also
   change that settings file and `.mcp.json`. The shared settings resource sets
   `permissions.defaultMode` to `acceptEdits` and enables Exa/Context7 MCP entries;
@@ -185,8 +187,10 @@ user's home; changing `OPENRIG_HOME` alone does not isolate provider configurati
   To keep your own status line alongside the collector, see
   [Custom Claude status line](docs/reference/claude-status-line.md).
 - **Codex:** writes the daemon's `CODEX_HOME/config.toml` (normally
-  `~/.codex/config.toml`). Startup enables hooks, adds the OpenRig activity relay
-  commands and pre-writes trust hashes for those commands. Seat startup adds
+  `~/.codex/config.toml`). With hooks enabled, daemon startup ensures the OpenRig
+  activity relay commands and their trust hashes when a Codex seat is already
+  recorded; otherwise the first Codex launch does so. With hooks disabled, startup
+  can remove a stale OpenRig-managed hook block even without a Codex seat. Seat startup adds
   `trust_level = "trusted"` for the workspace; selected config resources can
   add MCP settings. Managed launches pass `-c check_for_update_on_startup=false`,
   which writes no config; a recognized update notice that still appears can be
@@ -252,9 +256,12 @@ separates the desired selection from the last launch arguments; neither proves
 native enforcement. See the [permission guide](docs/reference/getting-started.md#per-seat-permission-mode).
 
 Managed hook blocks target OpenRig's entries and retain unrelated hooks, but
-trust entries, selected resource keys and Claude's existing status-line command
-can be replaced. Some writers recover unreadable settings as empty objects;
-this is not a complete preservation or rollback guarantee. Back up relevant
+trust entries and selected resource keys can be replaced. Claude's collector,
+activity-hook and JSON resource writers leave unreadable or malformed settings
+untouched; this is not a product-wide preservation guarantee. Codex's workspace
+trust writer can treat an unreadable `config.toml` as empty and write a new trust
+configuration. Read-modify-write operations can also race other writers; there
+is no complete preservation or rollback guarantee. Back up relevant
 files before first use. Daemon/bootstrap writes are automatic and do not each
 have an interactive preview; `rig setup --dry-run` does not preview every later
 startup effect.

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

@@ -1,6 +1,6 @@
 {
   "name": "openrig-core",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "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.13",
+  "version": "0.1.14",
   "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

@@ -26,8 +26,9 @@ This plugin ships dual-manifest packaging — both `.claude-plugin/` and `.codex
   A seat that has OpenRig's activity relay in its own `settings.local.json` (the `claude-activity-hooks` runtime resource)
   already reports activity from there, so the plugin's `activity-relay.cjs` (which the manifest starts with `--from-plugin`)
   exits for an event the seat's settings register it for. It does so only when the entry is exactly the one OpenRig writes
-  (`node` and one quoted path to `state/claude-activity-hooks/activity-relay.cjs`) and the script at that path is this same
-  script, so a missing script, a different one at that path, or a wrapper around it never silences the plugin. A seat without
+  (legacy `node` or a quoted absolute Node executable, then one quoted path to
+  `state/claude-activity-hooks/activity-relay.cjs`), the interpreter is executable, and the script at that path is this same
+  script. A missing interpreter/script, a different script, or a wrapper around it never silences the plugin. A seat without
   that resource, and a plugin installed outside OpenRig, report through the plugin's relay, so each event is reported once.
   A relay entry written by an older install (a different path or quoting) doesn't match, so until the seat is relaunched and
   its entry refreshed, both relays report and its events come twice. The plugin is not a Claude marketplace entry, so
@@ -43,6 +44,12 @@ This plugin ships dual-manifest packaging — both `.claude-plugin/` and `.codex
 - **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.
 
+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.
+
 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/scripts/activity-relay.cjs

@@ -214,15 +214,30 @@ function uid() {
 // each event once either way. Anything unreadable, missing or different counts as "not registered": a seat is never silent.
 const SETTINGS_RELAY_TAIL = "state/claude-activity-hooks/activity-relay.cjs";
 
-// The adapter's own test for the entry it writes (isOwnedRelayCommand): `node` and one single-quoted token, in the form
-// shellQuote produces, naming the relay copy. A wrapper that only mentions the path is not that entry. Returns the path.
+// Keep this finite generated-command grammar in parity with parseManagedClaudeNodeCommand.
+// Bare-node legacy commands and a canonical quoted absolute Node path are recognised;
+// extra arguments and user wrappers are not the settings relay.
 function settingsRelayPath(command) {
-  const m = /^node\s+(.+)$/.exec(command.trim());
-  const arg = m && m[1];
-  if (!arg || arg.length < 2 || !arg.startsWith("'") || !arg.endsWith("'")) return null;
-  const decoded = arg.slice(1, -1).split(`'"'"'`).join("'");
-  if ("'" + decoded.replace(/'/g, `'"'"'`) + "'" !== arg) return null;
-  return path.isAbsolute(decoded) && decoded.endsWith(`/${SETTINGS_RELAY_TAIL}`) ? decoded : null;
+  if (/[\r\n]/.test(command)) return null;
+  const m = /^(node|'(?:[^']|'"'"')*')[ \t]+('(?:[^']|'"'"')*')$/.exec(command.trim());
+  if (!m) return null;
+  const decode = token => token.slice(1, -1).split(`'"'"'`).join("'");
+  const quote = value => "'" + value.replace(/'/g, `'"'"'`) + "'";
+  const executable = m[1] === "node" ? "node" : decode(m[1]);
+  const relay = decode(m[2]);
+  if (quote(relay) !== m[2] || !path.isAbsolute(relay) || !relay.endsWith(`/${SETTINGS_RELAY_TAIL}`)) return null;
+  if (m[1] !== "node" && (quote(executable) !== m[1] || !path.isAbsolute(executable) || !/^node(?:\.exe)?$/i.test(path.basename(executable)))) return null;
+  return { executable, relay };
+}
+
+function interpreterAvailable(executable, env) {
+  const candidates = executable === "node"
+    ? typeof env.PATH === "string" ? env.PATH.split(path.delimiter).map(dir => path.resolve(dir || ".", "node")) : []
+    : [executable];
+  return candidates.some(candidate => {
+    try { fs.accessSync(candidate, fs.constants.X_OK); return fs.statSync(candidate).isFile(); }
+    catch { return false; }
+  });
 }
 
 // A settings entry only silences this run if it would really report: the file it names is there and is this very script.
@@ -243,7 +258,7 @@ function settingsRelayReports(hookEvent, providerPayload, env = process.env) {
     return Array.isArray(groups) && groups.some((group) => group && unrestricted(group) && Array.isArray(group.hooks)
       && group.hooks.some((hook) => {
         const relay = hook && typeof hook.command === "string" ? settingsRelayPath(hook.command) : null;
-        return relay !== null && isThisScript(relay);
+        return relay !== null && interpreterAvailable(relay.executable, env) && isThisScript(relay.relay);
       }));
   } catch {
     return false;
@@ -306,4 +321,5 @@ module.exports = {
   resolveEndpoint,
   pluginRunIsRedundant,
   settingsRelayReports,
+  settingsRelayPath,
 };

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

@@ -125,11 +125,14 @@ function readConfiguredContent(home) {
 // current work, its basis travels to the trace script, which alone decides how to render it;
 // a failed or unreadable answer is passed as UNKNOWN. Never guess a work node here: a guess
 // would silently re-point the whole trace.
-// OPR.0.7.0.12 — the work packet, switched off by default: the trace receives the daemon's
-// labelled work candidates and carries duties and notes as text. With it off, every path below
-// is unchanged.
+// OPR.0.7.0.12 — the work packet: the trace receives the daemon's labelled work candidates and
+// carries duties and notes as text. OPENRIG_REFOCUS_WORK_PACKET=1 turns it on and =0 off; unset, each
+// runtime's default below applies. A runtime defaults on only once a native run has shown the packet
+// reaching the agent and leading to the right next action; neither has yet. With it off, every path
+// below is unchanged.
+const WORK_PACKET_DEFAULT = { claude: false, codex: false };
 function workPacketEnabled() {
-  return enabled(process.env.OPENRIG_REFOCUS_WORK_PACKET, false);
+  return enabled(process.env.OPENRIG_REFOCUS_WORK_PACKET, WORK_PACKET_DEFAULT[runtime()] === true);
 }
 
 function readQueueWhoami(timeout = lookupTimeout()) {

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

@@ -109,6 +109,11 @@ When you `rig capture` a pane, **greyed / ghost autocomplete suggestions are NOT
 
 **Rule:** ignore ghost/autosuggest text entirely. Only *committed/rendered* pane output is real. When it matters, verify at source (git, the queue, the actual event) — never off a capture's ghost line.
 
+A plain capture loses the grey, so `rig capture` reads it for you. For a Claude Code or Codex seat, a
+`[rig capture: <seat>: input box: ...]` note on stderr (and `inputBox` in `--json`) says whether the input box's text
+is likely a harness suggestion or typed, from where the cursor is and whether the text is drawn faint. Don't act on
+`likely-suggestion` text as anyone's intent, and treat `unknown` as unknown: verify at source.
+
 ## Moment-of-truth checklist
 
 - **Starting a slice?** → do you know what it's for and what done looks like? mockups attached (UI slices)? **Are you on the light path?** (You are, unless the mission owner assigned the overlay.)

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

@@ -157,6 +157,27 @@ DUTY_HEADINGS = ("my job here", "standing duties")
 NOTES_STATE_HEADINGS = ("current state",)
 HEADING = re.compile(r"^(#{1,6})\s+(.*?)\s*#*\s*$")
 DEFAULT_NOTES_MAX_AGE_DAYS = 14
+# Each packet field is bounded on its own; there is no total cap. A row's summary and continuation are one line each,
+# the held and next lists show their newest rows with the full count, and a matched section's body is cut at a line.
+FIELD_CHARS = 160
+HELD_SHOWN = 20
+NEXT_SHOWN = 10
+SECTION_CHARS = 1500
+
+
+def one_line(text):
+    """(text as one line, cut to FIELD_CHARS, whether it was shortened)."""
+    flat = " ".join(str(text).split())
+    if len(flat) <= FIELD_CHARS:
+        return flat, flat != str(text).strip()
+    return flat[:FIELD_CHARS - 1].rstrip() + "…", True
+
+
+def bounded_section(body):
+    if len(body) <= SECTION_CHARS:
+        return body
+    boundary = body.rfind("\n", 0, SECTION_CHARS)
+    return body[:boundary if boundary > 0 else SECTION_CHARS].rstrip() + "\n[… use --depth full for the rest]"
 
 
 def heading_sections(text, wanted):
@@ -180,7 +201,7 @@ def heading_sections(text, wanted):
 
 def by_section(text, wanted, path):
     found = heading_sections(text, wanted)
-    shown = "\n\n".join(f"{title}\n{body}" if body else title for title, body in found)
+    shown = "\n\n".join(f"{title}\n{bounded_section(body)}" if body else title for title, body in found)
     missing = [phrase for phrase in wanted if not any(title.lower().startswith(phrase) for title, _ in found)]
     if not missing:
         return shown
@@ -335,28 +356,51 @@ def candidate_line(candidate):
     return line
 
 
+def row_fields(row, *fields):
+    """Each named field as one bounded line, and a pointer to the whole row when any was shortened."""
+    values, cut = [], False
+    for field, missing in fields:
+        value, shortened = one_line(row.get(field) or missing)
+        values.append(value)
+        cut = cut or shortened
+    pointer = f" — full row: rig queue show {row['qitemId']}" if cut and row.get("qitemId") else ""
+    return values, pointer
+
+
+def cut_notice(name, state, rows, shown, daemon_cut):
+    """The list's notice when it was cut here or by the daemon: how many are shown, of how many."""
+    if not daemon_cut and len(rows) <= shown:
+        return None
+    total = f"more than {len(rows)}" if daemon_cut else str(len(rows))
+    return (f"(the {name} list was cut: {min(len(rows), shown)} of {total} shown; "
+            f"`rig queue list --owned --state {state}` has the rest)")
+
+
 def render_held_and_next(evidence):
     output = []
+    per_list = "heldTruncated" in evidence or "nextTruncated" in evidence
     held = evidence.get("held") or []
     if held:
         output.append("HELD WORK (blocked; this is not next):")
-        for row in held:
-            output.append(f"- {row.get('qitemId') or 'a row'} — {row.get('summary') or 'no summary'} — "
-                          f"blocked on {row.get('blockedOn') or 'unknown'} — "
-                          f"continuation: {row.get('continuation') or 'none recorded'}")
+        for row in held[:HELD_SHOWN]:
+            (summary, blocked_on, continuation), pointer = row_fields(
+                row, ("summary", "no summary"), ("blockedOn", "unknown"), ("continuation", "none recorded"))
+            output.append(f"- {row.get('qitemId') or 'a row'} — {summary} — blocked on {blocked_on} — "
+                          f"continuation: {continuation}{pointer}")
     following = evidence.get("next") or []
     if following:
         output.append("POSSIBLE NEXT WORK (pending; no order implied):")
-        for row in following:
+        for row in following[:NEXT_SHOWN]:
             missions = ", ".join(row.get("missions") or [])
-            output.append(f"- {row.get('qitemId') or 'a row'} — {row.get('summary') or 'no summary'}"
-                          + (f" [mission: {missions}]" if missions else ""))
-    if "heldTruncated" in evidence or "nextTruncated" in evidence:
-        if evidence.get("heldTruncated"):
-            output.append("(the held list was cut; `rig queue list --owned --state blocked` has the rest)")
-        if evidence.get("nextTruncated"):
-            output.append("(the next list was cut; `rig queue list --owned --state pending` has the rest)")
-    elif evidence.get("heldAndNextTruncated"):
+            (summary,), pointer = row_fields(row, ("summary", "no summary"))
+            output.append(f"- {row.get('qitemId') or 'a row'} — {summary}"
+                          + (f" [mission: {missions}]" if missions else "") + pointer)
+    notices = [
+        cut_notice("held", "blocked", held, HELD_SHOWN, per_list and bool(evidence.get("heldTruncated"))),
+        cut_notice("next", "pending", following, NEXT_SHOWN, per_list and bool(evidence.get("nextTruncated"))),
+    ]
+    output.extend(notice for notice in notices if notice)
+    if not per_list and evidence.get("heldAndNextTruncated"):
         output.append("(held and next lists were cut; `rig queue list` has the rest)")
     return "\n".join(output)
 
@@ -390,8 +434,9 @@ def render_candidates(evidence, root, depth, failures):
         output.extend(candidate_line(candidate) for candidate in candidates)
     if unknown:
         output.append("In-progress rows the queue cannot place:")
-        output.extend(f"- {row.get('qitemId') or 'a row'} — {row.get('summary') or 'no summary'}: {row.get('reason')}"
-                      for row in unknown)
+        for row in unknown:
+            (summary,), pointer = row_fields(row, ("summary", "no summary"))
+            output.append(f"- {row.get('qitemId') or 'a row'} — {summary}: {row.get('reason')}{pointer}")
     if not candidates:
         names = evidence.get("missionsOnHost") or []
         if names:

package/daemon/assets/skills/rigs/SKILL.md

@@ -15,9 +15,13 @@ building it yourself.
 
 Tell the person what you're about to run and why before you run it. Don't install system packages or change their
 machine without a yes. Starting OpenRig and a team writes files: Codex hooks and settings in
-`~/.codex/config.toml`, a discovery skill in `~/.claude/skills` and `~/.agents/skills`, and, in the repository, managed
-guidance in `AGENTS.md` or `CLAUDE.md` plus the team's skills and plugins. Say so before you start OpenRig
-([the full list](https://github.com/mvschwarz/openrig#what-openrig-changes-on-your-machine)).
+`~/.codex/config.toml`, Claude Code workspace trust in `~/.claude.json`, discovery skills in `~/.claude/skills` and
+`~/.agents/skills`, and, in the repository, managed guidance in `AGENTS.md` or `CLAUDE.md`, activity hooks in
+`.claude/settings.local.json` and a status line there unless the project already has its own, plus the team's skills
+and plugins. Unless a permission policy, a per-seat choice or (for Codex) a named profile applies, the kernel's own
+seats run with an operational default: Codex with `-s danger-full-access -a never`, and Claude Code with its file
+tools, web fetches and operational commands, including reads under the home folder, allowed without asking. Say so
+before you start OpenRig ([the full list](https://github.com/mvschwarz/openrig#what-openrig-changes-on-your-machine)).
 
 ## 1. Install OpenRig, if it isn't installed
 
@@ -178,4 +182,4 @@ offer, so the person sees the real file, not a placeholder:
 - **Everything in the library:** `rig context list`.
 - **Exact syntax:** `rig <command> --help` is always current for the installed version.
 
-Written for OpenRig 0.6.7. When something here and `--help` disagree, `--help` wins.
+When something here and `rig <command> --help` disagree, `--help` wins.

package/daemon/context-packs/help/manifest.yaml

@@ -1,6 +1,6 @@
 # Agent help: the single troubleshooting and escalation guide (docs/reference/help.md).
 name: help
-version: "0.6.12"
+version: "0.6.13"
 taxonomy: world
 purpose: "What an agent does when its user says OpenRig isn't working: diagnose, fix within permissions, verify, and escalate to OpenRig support."
 files:

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

@@ -1,6 +1,6 @@
 # Public capability and source-map width for the default onboarding walk.
 name: onboarding-width
-version: "0.6.12"
+version: "0.6.13"
 taxonomy: world
 purpose: "The public capability map and source map referenced by the default onboarding walk."
 files:

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-eight top-level verbs ship (capability canon refreshed through
-`capability-delta-v0.6.12`). This marker describes the pack's teaching, not publication or live
+`capability-delta-v0.6.13`). This marker describes the pack's teaching, not publication or live
 adoption. 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,11 @@ one command away. Your memory of the fleet is a claim about the past.
   filters to running and **hides detached, exited and attention states** — which are exactly the
   cells you were scanning for. A seat whose tmux session is confirmed gone reads `detached`
   (activity reason `session_missing`), and `rig ps --nodes` says to restore or relaunch it.
+  `rig ps --nodes` also shows the model each seat was last seen using (`modelObservation`, with its
+  source and time), or unknown; it never shows the configured model in its place. A Claude seat at
+  Claude Code's MCP-server approval menu reads as needing input (`mcp_gate`), a Codex seat at its
+  folder-trust panel reads `trust_gate`, and an OMP seat whose turn ended with a typed transient
+  provider failure reads idle and takes an ordinary retry.
   **`rig ps --resources`** shows this host's load and transcript capture cost.
 - **`rig ps --all-hosts --nodes -A`** — the same across every registered machine. Rollup-only
   unless you ask for nodes.
@@ -74,7 +79,7 @@ one command away. Your memory of the fleet is a claim about the past.
 - **`rig roster list` / `show` / `find`** — who across your rigs and hosts is recommended for a
   kind of work, from JSON rosters in `<workspace.root>/rosters`. Read-only: it dispatches nothing
   and does not claim anyone is available. The built-in starter and factory leads publish their
-  team's roster at first start.
+  team's roster at first start. `show` and `find` include each seat's last observed model.
 - **`rig telemetry events` / `transitions` / `tenures <node-id>`** — past events, queue
   transitions and a seat's occupants, one bounded page at a time with gaps reported. Reach for it
   before querying the database yourself.
@@ -98,7 +103,9 @@ unseen — which makes messages the one delivery channel that never gets skipped
   that seat aren't held behind it; N is a deadline from the start of the wait.
   Over `--host` to an http-registered host, a send that may have reached the remote reads
   `remote-outcome-unknown` ("Delivery UNCONFIRMED"): check the target with `rig capture <session>
-  --host <id>` before any resend. Only a host that was never reached reads as unreachable.
+  --host <id>` before any resend. Only a host that was never reached reads as unreachable. A send
+  whose caller goes away (Ctrl-C, or its own timeout) before input starts is refused with
+  `caller_cancelled` and never types later.
 - **`rig send --raw`** — send exact text or keystrokes without the From/To envelope;
   the interactive-prompt guard still applies. To deliberately drive an interactive prompt,
   **`--dangerously-interact --reason "<why>"`** is the explicit override and implies raw text.
@@ -116,7 +123,9 @@ unseen — which makes messages the one delivery channel that never gets skipped
   every seat in one call. `--lines N` is the last N lines (stderr says how many earlier lines were
   cut); `--history-plus-pane` gives the older N history lines plus the whole pane. A short capture
   doesn't prove a seat is idle: a capture that cut lines says activity is unknown (`activity:
-  "unknown"` in `--json`), so read `rig ps --nodes` for it.
+  "unknown"` in `--json`), so read `rig ps --nodes` for it. For a Claude Code or Codex seat, stderr
+  notes whether the input box's text looks typed or like a faint harness suggestion (`inputBox` in
+  `--json`); it's a heuristic, and `unknown` means unknown.
 - **`rig transcript <seat>`** — what has been *said* in a seat, and **seat-scoped rather than
   session-scoped**: one file spanning every agent generation that has occupied it, so it reaches
   back through handovers. Capped (`transcripts.lines`, default 1000 — raise it for depth), and
@@ -170,7 +179,10 @@ unseen — which makes messages the one delivery channel that never gets skipped
 - **`rig slack`** — inspect and manage one connector implementation. Use registered-human
   readiness for the delivery decision and `queue create --verify` for its receipt; connector
   setup or verification is not an outbound human message. After a connection gap the daemon
-  catches up on missed channel messages and marks them late; `rig slack status` shows the
+  catches up on missed messages in the channels this machine owns (its default channel, its
+  channel map's, and on a relayed machine each channel the hub has relayed to it) and on replies
+  in tracked threads whose root or close is within seven days; recovered replies are marked late
+  and never answer a decision. `rig slack status` shows the
   connection, the catch-up state, and the count of retained retry records for inbound messages,
   reactions and click answers (kept across restarts, not a distinct-message count). A retained alert whose row closed before its retry isn't
   posted; the row says why. Its `Delivery:` line says whether events are confirmed arriving;
@@ -389,7 +401,8 @@ not have to tear one down to change it, and you rarely have to start from nothin
 - **`rig up <source>`** — make a whole rig exist and run: from a spec you wrote, a shipped starter
   by name, a bundle someone handed you, a GitHub folder link (pinned to one commit), or a stopped
   rig. `rig up` with a pod-aware spec on a stopped team's name replaces that team (the earlier one
-  is archived), so check `rig ps --nodes` first. Launch-created `AGENTS.md` or `CLAUDE` files now show in `git status`.
+  is archived), so check `rig ps --nodes` first. A rig name containing a dot is refused before
+  launch, because tmux would rename its sessions. Launch-created `AGENTS.md` or `CLAUDE` files now show in `git status`.
   `rig up <rig> --existing` puts back the OpenRig guidance blocks `rig down` removed before a
   resumed seat starts. A seat still missing one makes the rig `partially_restored` (its node lists
   `guidanceGaps`) and `rig up` exits 1. A seat that wasn't running at the snapshot, but whose
@@ -426,8 +439,13 @@ not have to tear one down to change it, and you rarely have to start from nothin
   <account>` reports `moved` only when a tool turn has completed in the same conversation since
   the restart and Codex's status names that account. Linux only: on macOS a
   request that reaches the running-process check refuses before stopping the seat.
+  An adopted seat (one OpenRig didn't launch) refuses with `claimed_session`. "A conversation it
+  can prove" means the stored conversation matches the one the running Codex's command line names
+  (or, when it names none, the only one Codex has logged since it started); OpenRig can't tell
+  which conversation Codex is on now. If the conversation was changed inside the running Codex,
+  the restart may refuse or resume the earlier one, so look at the pane (`rig capture <seat>`) first.
 - **`rig add`** / **`rig expand`** — graft one more member, or a whole new pod, onto a rig that is
-  already running. `rig add` takes the rig's name or ID; a name two active rigs share is refused
+  already running. `rig add`, `rig grow` and `rig remove` take the rig's name or ID; a name two active rigs share is refused
   with `rig_ambiguous` and the candidates. `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
@@ -543,6 +561,16 @@ version, from checking the environment to a useful report to the OpenRig team.
   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 seat set-cwd <seat> --cwd <absolute-path> --reason <text>`** — save an existing seat's
+  launch directory, audited, for its next fresh launch or rebuild handover. Its node, address, queue
+  and history stay intact. It creates the folder (on the daemon's host) and writes nothing else there: launch writes the
+  startup files, as today. Its preflight policy refuses, naming the paths, when the new directory
+  holds an edited, unrecorded-and-different or doubly sourced copy that launch would place. The
+  running process keeps its directory: adopt the new one with `rig seat launch <seat> --fresh
+  --stop --reason <text>` or a rebuild handover, promptly (background work, such as a Claude seat's
+  managed compaction, can use the saved directory before then; that's guidance, not a guard), and
+  before any `rig down`/`rig up` or fork handover. In-place Codex restart isn't adoption. `rig seat status` shows the
+  saved `launch_cwd`. Old-directory files are left.
 - **`rig seat set-permissions <seat> --mode <mode> --reason <text>`** — select one seat's native
   permission mode for its future managed launches; it relaunches nothing, and `inherit` clears the
   selection. `rig seat status` reports the selection, but a status read does not prove the
@@ -551,7 +579,7 @@ version, from checking the environment to a useful report to the OpenRig team.
   reasoning effort for its next launch, restore, handover or in-place Codex restart without
   touching its spec or its peers; nothing restarts. **`rig seat effort <seat>`** reports what was
   requested, what's saved, what the running process was launched with and what the session
-  recorded (NOT VERIFIED until the seat takes a turn).
+  recorded (NOT VERIFIED until the seat takes a turn). It works for Pi seats too, sent as `--thinking`.
 - **`rig seat set-typing-guard <seat> --mode off|draft-aware|hold --reason <text>`** — choose
   ordinary automatic delivery, immediate retention when input is busy/unreadable, or holding all automatic
   input. `--enabled true|false` remains compatible: true selects hold, false selects off.
@@ -572,6 +600,8 @@ version, from checking the environment to a useful report to the OpenRig team.
   `submitted, unconfirmed` (it reached the seat, not proof compaction ran), `uncertain` (not
   replayed) or `not sent`, so confirm by effect. Claude seats that select `openrig-core` load its
   hooks; a seat can give a slow refocus more time with `OPENRIG_REFOCUS_BUDGET_MS` (4500 to 52000).
+  The refocus work packet stays off by default for Claude Code and Codex;
+  `OPENRIG_REFOCUS_WORK_PACKET=1` turns it on, with each field bounded.
 - **Know what compaction costs before you reach for it.** On some runtimes what comes back has
   enough context left to believe it knows everything and not enough to actually know anything — and
   **the compacted agent is the only one who knows it happened**, while every other seat keeps
@@ -848,9 +878,9 @@ your circumstances is configuration, and the ones that are not, another agent ca
   permission policy: an explicit flag wins over it, and it wins over the operator default
   `launch.non_interruptive`. The before-install view shows it as
   `posture[].nonInterruptiveDefault`.
-- **Smaller settings worth knowing:** per-seat `effort`, passed to Claude as `--effort` and to
-  Codex as `model_reasoning_effort` (`rig seat set-effort` overrides it for one seat); and
-  `runtime.readiness_timeout_seconds` for seats that start slowly.
+- **Smaller settings worth knowing:** per-seat `effort`, passed to Claude as `--effort`, to
+  Codex as `model_reasoning_effort` and to Pi as `--thinking` (`rig seat set-effort` overrides it for
+  one seat); and `runtime.readiness_timeout_seconds` for seats that start slowly.
 - **`rig policy cite` / `defaults`** — what posture the operator is in: how autonomous to be, how
   loudly to report, whether to batch permission questions or block on them. **This declares a
   posture; it does not grant or deny permissions** — the harness's own settings are the control
@@ -879,7 +909,12 @@ your circumstances is configuration, and the ones that are not, another agent ca
   windows, listed once per allowance and never added up; `--refresh` (optionally `--provider
   codex|claude`) reads the logins now. A Claude account's current availability reads `unknown`,
   because nothing links a seat's reading to the login it used: read each window as that seat's
-  reading, and don't tell a person an account has room from it. With `provider.subscription_moves`
+  reading, and don't tell a person an account has room from it. Each account row also carries a
+  sign-in fact (`usable`, `needs sign-in` or `unknown`); a signed-in Claude login never reads
+  better than `unknown`. A Codex account's last reading, its reset and its last observed exhaustion
+  survive a daemon restart as history (`retained: "before_restart"`), never a current reading; a
+  window whose reset has passed shows an `expectation`, which is planning, not a reading. Run `rig provider status --refresh`
+  before telling anyone an account has room. With `provider.subscription_moves`
   on (off by default), `rig provider moves` records and lists moves of a Codex home's seats between
   subscriptions.
 - **Codex configuration fragments** — a `codex_config_fragment` must open with a table header and
@@ -893,6 +928,19 @@ your circumstances is configuration, and the ones that are not, another agent ca
   `both` sets which harnesses it installs and checks; one not chosen reads `skipped`, never failed.
 - **`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 usage top`** — which of this machine's seats used the most tokens over a window (`--window
+  90m`, `1h`, `2d`; `--top <n>` caps the list). Each ranked seat shows its token delta and samples;
+  a seat that has reported usage before but has no usable samples in the window is listed as
+  unknown with its reason, never as zero.
+  To compare machines, run it on each machine, or against each machine's daemon with
+  `OPENRIG_URL=<that daemon's URL>`, back to back, with the same `--window`, no `--top`, and `--json`.
+  Show the results side by side in tokens. For each machine, give its host, the window and its
+  `sinceIso` (each daemon counts from its own clock), how many seats were ranked and over what span,
+  the unknown seats and their reasons, and each seat's runtime, declared `model` and last observed
+  model (`modelObservation`: model, source, time) from `rig ps --nodes -A --json` on that machine.
+  A seat that has never reported usage is in neither list: name each seat that `rig ps --nodes -A
+  --json` shows and `rig usage top` doesn't as not covered. Don't add machines into one total unless
+  they cover the same seats over the same span; where coverage differs, say so instead.
 - **`rig usage cost [--seat <session>]`** — what each seat's harness reports it costs, beside its
   tokens: Claude's own client-side estimate (not an invoice) and Codex's tokens with a note that it
   reports no cost. A missing figure reads missing, never $0, and no setting gates it. With