@openrig/cli 0.6.12 → 0.6.14

package/README.md

@@ -8,28 +8,74 @@ OpenRig is open-source software for building and running your own network of age
 
 It's the open-source system behind my AI civilization experiments.
 
-**Guide:** [Getting started](docs/reference/getting-started.md) · **Stuck?** [Help](docs/reference/help.md) · **Questions:** [Q&A](https://github.com/mvschwarz/openrig/discussions/92) · **Updates and demos:** [@_feralmachine on X](https://x.com/_feralmachine)
+**Guide:** [Getting started](docs/reference/quickstart.md) · **Stuck?** [Help](docs/reference/help.md) · **Questions:** [Q&A](https://github.com/mvschwarz/openrig/discussions/92) · **Updates and demos:** [@_feralmachine on X](https://x.com/_feralmachine)
 
 ## See it running
 
 ![The OpenRig TUI: the build rig as a graph, then as a table of seats with runtime, model, context and state, then one seat in detail (real recording, 10 seconds)](assets/readme/openrig-agents-working.gif)
 
-**Start here:** [the guided first-use path](docs/reference/getting-started.md): install, talk to the kernel operator, then choose a team for your first useful change.
+**Start here:** [the guided first-use path](docs/reference/quickstart.md): install, talk to the kernel operator, then choose a team for your first useful change.
 
 Not setting this up today? Get the next walkthrough and occasional OpenRig updates → https://openrig.dev/follow
 
 ## 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.
+**Let your coding agent set it up.** First check that `node --version` shows 22 or 24: the command below needs
+Node.js and the `npx` that comes with it. Then, in your project folder, add OpenRig's `rigs` skill to the agent you
+use:
 
-**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:
+```sh
+# Claude Code
+npx skills add https://github.com/mvschwarz/openrig/tree/v0.6.14/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
+```
+
+Then type `/rigs` in Claude Code, or `$rigs` in Codex, and say what you want built. The skill has your agent tell
+you what it will run and change before it does, install OpenRig, open the OpenRig view and pass your goal to
+OpenRig's operator.
+
+You need Node.js 22 or 24 (22 on Apple silicon), tmux, macOS or Linux (WSL2 on Windows), and Claude Code or Codex
+signed in. One provider is enough to start.
+
+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).
+
+> **What OpenRig changes on your machine**
+> - **Install:** `@openrig/cli` goes in globally with npm.
+> - **Setup:** `rig setup` adds an OpenRig block to `~/.tmux.conf`. It can install tmux (with Homebrew on macOS), and
+>   Herdr unless you pass `--no-herdr`. Plain `rig setup`, which is what the one-command install runs, checks both
+>   Claude Code and Codex and may install a missing one; `rig setup --providers claude` (or `codex`) limits it to
+>   yours.
+> - **Starting OpenRig, for the coding agent you use** (paths are the usual defaults):
+>   - Codex: hooks and trust in `~/.codex/config.toml`.
+>   - Claude Code: workspace trust in `~/.claude.json`, and activity hooks in the project's
+>     `.claude/settings.local.json`, plus a status line unless you already have your own.
+>   - Discovery skills go in `~/.claude/skills` and `~/.agents/skills`.
+> - **Starting a team in your project:** adds managed guidance to `AGENTS.md` or `CLAUDE.md`, plus the team's skills
+>   and plugins.
+> - **Permissions:** by default, OpenRig's own kernel gets broader permissions than a project team gets by default.
+>   On Codex that's full access with no approval prompts (`-s danger-full-access -a never`). On Claude Code, its file
+>   tools, web fetches and operational commands, including reads under your home folder, run without asking. A
+>   permission policy, per-agent choice or Codex profile changes that. What your team can do depends on the team you
+>   choose and your settings; `workshop`, for example, ships with broad access.
+> - **Backups:** OpenRig doesn't guarantee it can preserve or roll back these files, so back them up first.
+>
+> [Everything OpenRig writes, and why →](https://github.com/mvschwarz/openrig#what-openrig-changes-on-your-machine)
+
+### 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:
 
 ```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.14/scripts/install.sh | sh -s -- --dry-run
+curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.14/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 +207,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 +221,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 +233,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 +302,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.
@@ -335,6 +388,8 @@ For cmux, use `--provider cmux`. In the TUI, a rig's detail view has an `Open te
 
 ## Key Concepts
 
+The first words you meet, in plain language: [What these words mean](docs/reference/quickstart.md#what-these-words-mean).
+
 - **RigSpec**: Declarative multi-agent harness definition in YAML. Pods, members, edges, continuity policies, culture file.
 - **AgentSpec**: Reusable agent blueprint with skills, guidance, hooks, profiles, and startup contracts.
 - **Seat**: A stable role and address in a rig, such as `dev-build@starter`. The conversation occupying it can change while its identity and authored context remain.

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

@@ -1,6 +1,6 @@
 {
   "name": "openrig-core",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "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.15",
   "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/openrig-user/SKILL.md

@@ -384,11 +384,19 @@ rig reconcile-session <session>
 rig reconcile-session <session> --rig <rigId> --node <logicalId>
 rig reconcile-session <session> --no-launch
 rig reconcile-session <session> --json
+rig reconcile-session <session> --repair-missing-pane --no-launch
 ```
 
-This is a no-launch, no-input adopt. `--rig`/`--node` disambiguate when the
-canonical session name does not uniquely resolve. `--no-launch` is accepted
-for explicitness (it is the only mode this command has).
+This is a no-launch, no-input adopt: it records a new claimed session row for
+the seat (any running row is superseded); it re-captures the resume token if
+it can, and conversation continuity stays unverified. `--rig`/`--node`
+disambiguate when the canonical session name does not uniquely resolve.
+`--no-launch` is accepted for explicitness.
+
+`--repair-missing-pane --no-launch` is different: for a running launched seat
+whose tmux pane was never recorded, it fills in the pane and keeps the
+session, resume token and generation. It never adopts. Both forms refuse
+while the seat's typing protection is on.
 
 ### Five-term restore status vocabulary
 

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

@@ -75,39 +75,19 @@ def read(path):
         return None
 
 
+# Contract twin of CLI scope-fs.ts and daemon scope/node-file.ts; parity is tested.
+NOTES_FILE_PRECEDENCE = ("NOTES.md", "MISSION_NOTES.md")
+
+
 def resolve_notes(node):
-    try:
-        result = subprocess.run(
-            ["rig", "scope", "resolve-notes", str(node), "--json"],
-            capture_output=True,
-            text=True,
-            timeout=10,
-            check=False,
-        )
-    except subprocess.TimeoutExpired:
-        return None, "resolver command timed out"
-    except OSError as error:
-        return None, f"resolver command could not start: {error}"
-    if result.returncode != 0:
-        detail = (result.stderr or result.stdout or "").strip().splitlines()
-        suffix = f": {detail[0]}" if detail else ""
-        return None, f"resolver command exited {result.returncode}{suffix}"
-    try:
-        payload = json.loads(result.stdout)
-    except (json.JSONDecodeError, TypeError):
-        return None, "resolver command returned malformed JSON"
-    if not isinstance(payload, dict) or payload.get("ok") is not True or "resolution" not in payload:
-        return None, "resolver command returned an invalid success shape"
-    resolution = payload["resolution"]
-    if resolution is None:
-        return None, None
-    if not isinstance(resolution, dict):
-        return None, "resolver command returned an invalid resolution shape"
-    resolved_path = resolution.get("path")
-    resolved_name = resolution.get("name")
-    if not isinstance(resolved_path, str) or not isinstance(resolved_name, str):
-        return None, "resolver command returned an invalid resolution shape"
-    return (Path(resolved_path), resolved_name), None
+    for name in NOTES_FILE_PRECEDENCE:
+        candidate = node / name
+        try:
+            if candidate.is_file() and os.access(candidate, os.R_OK):
+                return (candidate, name), None
+        except OSError:
+            pass
+    return None, None
 
 
 def intent(text):
@@ -157,6 +137,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 +181,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 +336,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 +414,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.14"
 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.14"
 taxonomy: world
 purpose: "The public capability map and source map referenced by the default onboarding walk."
 files: