@openrig/cli 0.6.11 → 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.8` 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.8/scripts/install.sh | sh -s -- --dry-run
-curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.8/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:**
 
@@ -144,6 +144,7 @@ Not setting this up today? Get the next walkthrough and occasional OpenRig updat
 - **Questions:** [Discussions › Q&A](https://github.com/mvschwarz/openrig/discussions/categories/q-a)
 - **Bugs and feature requests:** [open an issue](https://github.com/mvschwarz/openrig/issues/new/choose)
 - **Contributing:** [CONTRIBUTING.md](CONTRIBUTING.md) · [Code of Conduct](CODE_OF_CONDUCT.md) · [Security policy](SECURITY.md) · [Getting help](.github/SUPPORT.md)
+- **Working on OpenRig with a coding agent?** Start with the `developing-openrig` skill in `.agents/skills/` (Claude Code: `.claude/skills/`) and [CONTRIBUTING.md](CONTRIBUTING.md).
 - **Videos:** [youtube.com/@openrig](https://www.youtube.com/@openrig)
 - **Releases:** [GitHub Releases](https://github.com/mvschwarz/openrig/releases) and npm `@openrig/cli`
 
@@ -160,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. |
@@ -174,16 +175,22 @@ 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;
   selected MCP resources configure those external services. Built-in bootstrap
   no longer writes a command allowlist to `~/.claude/settings.json` or removes
   older allowances. `CLAUDE_CONFIG_DIR` does not relocate the project-local writes.
+  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
@@ -249,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.
@@ -297,7 +307,7 @@ rig specs ls
 
 ## How It Works
 
-OpenRig is a local daemon + CLI + terminal UI + MCP server, built on tmux. The older React web UI remains in maintenance mode with best-effort support.
+OpenRig is a local daemon + CLI + terminal UI + MCP server, built on tmux. OpenRig itself is under active development; only the older React web UI is in maintenance mode, with best-effort support.
 
 ```
 CLI / TUI / MCP

package/daemon/assets/claude-statusline-context.cjs

@@ -44,6 +44,8 @@ process.stdin.on("end", () => {
       session_name: raw.session_name ?? null,
       occupant_generation: process.env.OPENRIG_OCCUPANT_GENERATION || process.env.RIGGED_OCCUPANT_GENERATION || null,
       transcript_path: raw.transcript_path ?? null,
+      // Claude's own client-side cost estimate for this session (cumulative; not an invoice).
+      cost: raw.cost && typeof raw.cost.total_cost_usd === "number" ? { total_cost_usd: raw.cost.total_cost_usd } : null,
       sampled_at: new Date().toISOString(),
     };
 

package/daemon/assets/guidance/openrig-start.md

@@ -12,7 +12,8 @@ orientation, and it cannot tell you what your rig is for or what you are suppose
 rig whoami --json
 ```
 
-Returns your rig, pod, member, peers, edges, and transcript path. **Treat it as ground truth.**
+Returns your rig, pod, member, peers, edges, and transcript path. If `peersNote` says some peers
+are not shown, `rig whoami --json --all-peers` lists them all. **Treat it as ground truth.**
 A startup overlay can be stale; this one is small precisely so it has less room to be wrong.
 
 Run it again after any compaction, restart or restore — **before** concluding anything about

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

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

@@ -13,10 +13,42 @@ off, and never runs at fresh session start.
 
 ## Runtimes
 
-This plugin ships dual-manifest packaging — both `.claude-plugin/` and `.codex-plugin/`. Use it with:
-
-- **Claude Code** — install via `/plugin` after the OpenRig daemon vendors `openrig-core/` to `~/.openrig/plugins/openrig-core/` on first run, or install the plugin directly through Claude Code's own plugin commands when remote distribution is available
-- **Codex CLI** — install via `/plugins` after the same vendoring step, or directly through Codex's own plugin commands
+This plugin ships dual-manifest packaging — both `.claude-plugin/` and `.codex-plugin/`.
+
+- **Claude Code** — the OpenRig daemon vendors `openrig-core/` to `$OPENRIG_HOME/plugins/openrig-core/` at startup and starts
+  each Claude seat whose resolved plugin selection includes it (for example `plugins: [shared:openrig-core]`) with
+  `CLAUDE_CODE_PLUGIN_DIRS` pointing at that copy, so the plugin's hooks (refocus, compaction restore) load with no setup
+  step. A seat that didn't select the plugin is launched as before. This applies to fresh launches, restores, handover
+  successors and launches with a permission mode; a seat that was already running picks it up at its next launch. A
+  `CLAUDE_CODE_PLUGIN_DIRS` list a seat declares itself (its spec's `env:` or a one-off `rig up --env`) keeps working: the
+  vendored plugin is added after it. Claude Code reads the variable from v2.1.280; an older Claude ignores it, starts
+  normally, and doesn't load the hooks (OpenRig doesn't check the version or refuse the launch).
+  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
+  (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
+  `/plugin` has nothing to install.
+  **A Claude started inside a seat** (from its shell or its Bash tool) inherits the seat's environment, so it loads the
+  plugin too. OpenRig gives such a seat `OPENRIG_SEAT_PROJECT_DIR`, its launch project, and the plugin's seat effects (the
+  activity and session-identity posts, the compaction hooks, refocus, and the first-launch marker) run only when the Claude's
+  own `CLAUDE_PROJECT_DIR` is that folder (compared by real path). So a Claude in another project, or in a subfolder of the
+  seat's project, doesn't act as the seat, and a `cd` inside the seat's own session doesn't switch it off, because
+  `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.
+
+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
@@ -30,7 +62,7 @@ All other skills are cross-runtime by design.
 The npm package includes an offline baseline under the daemon's
 `assets/plugins/openrig-core/`. The daemon resolves local plugin authority before
 attempting a network fetch, using the configured OpenRig home (normally
-`~/.openrig/plugins/openrig-core/` for the installed copy):
+`$OPENRIG_HOME/plugins/openrig-core/` for the installed copy):
 
 | Installed state | Local vendoring behavior |
 | --- | --- |
@@ -52,8 +84,6 @@ resolved local copy in place. A successful fetch also leaves it unchanged.
 This describes the fetch implementation, not a claim that a release artifact is
 currently available at the external repository.
 
-You can also install directly via Claude Code or Codex's own plugin commands if you prefer to manage plugins outside OpenRig.
-
 ## License
 
 Apache License 2.0. See `LICENSE`.

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

@@ -5,7 +5,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\"",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\" --from-plugin",
             "timeout": 5
           }
         ]
@@ -26,7 +26,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\"",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\" --from-plugin",
             "timeout": 5
           }
         ]
@@ -45,7 +45,7 @@
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/refocus.cjs\" --runtime claude",
-            "timeout": 5
+            "timeout": 60
           }
         ]
       }
@@ -76,7 +76,7 @@
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/refocus.cjs\" --runtime claude",
-            "timeout": 5
+            "timeout": 60
           }
         ]
       }
@@ -86,7 +86,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\"",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\" --from-plugin",
             "timeout": 5
           }
         ]
@@ -96,7 +96,7 @@
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/refocus.cjs\" --runtime claude",
-            "timeout": 5
+            "timeout": 60
           }
         ]
       }
@@ -106,7 +106,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\"",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/activity-relay.cjs\" --from-plugin",
             "timeout": 5
           }
         ]

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

@@ -26,7 +26,7 @@
           {
             "type": "command",
             "command": "node \"${PLUGIN_ROOT}/hooks/scripts/refocus.cjs\" --runtime codex",
-            "timeout": 5
+            "timeout": 60
           }
         ]
       }
@@ -48,7 +48,7 @@
           {
             "type": "command",
             "command": "node \"${PLUGIN_ROOT}/hooks/scripts/refocus.cjs\" --runtime codex",
-            "timeout": 5
+            "timeout": 60
           }
         ]
       }

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

@@ -78,6 +78,7 @@ function buildOpenRigPayload(providerPayload, env = process.env, now = () => new
     generation,
     hookEvent,
     subtype,
+    turnId: firstString(providerPayload.turn_id, providerPayload.turnId),
     occurredAt: now().toISOString(),
   };
 }
@@ -205,8 +206,97 @@ function uid() {
   try { return typeof process.getuid === "function" ? String(process.getuid()) : "user"; } catch { return "user"; }
 }
 
+// OpenRig also copies this script into a seat's own settings.local.json hooks (the claude_activity_hooks resource), so a
+// seat that loads this plugin as well would post every event twice. The plugin's manifest starts the plugin's run with
+// --from-plugin; that run looks at the seat's project settings.local.json and exits only when the OpenRig copy is
+// registered there for this very event. The settings copy is started without that argument and always reports, and so does
+// a seat whose settings have no such entry (the resource is optional) or a plugin installed on its own, so a seat reports
+// 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";
+
+// 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) {
+  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.
+// A missing script, or a different one at that path (a no-op, a stale copy from an older install), reports from the plugin.
+function isThisScript(file) {
+  try { return Buffer.compare(fs.readFileSync(file), fs.readFileSync(__filename)) === 0; } catch { return false; }
+}
+
+function settingsRelayReports(hookEvent, providerPayload, env = process.env) {
+  const projectDir = firstString(env.CLAUDE_PROJECT_DIR, providerPayload && providerPayload.cwd);
+  if (!projectDir || !hookEvent) return false;
+  try {
+    const settings = JSON.parse(fs.readFileSync(path.join(projectDir, ".claude", "settings.local.json"), "utf8"));
+    const groups = settings && settings.hooks && settings.hooks[hookEvent];
+    // A group with a matcher may not run for this event, so only an unrestricted group (no matcher, "" or "*") counts;
+    // OpenRig writes its group without one. Anything else reports, at worst twice, never not at all.
+    const unrestricted = (group) => group.matcher === undefined || group.matcher === "" || group.matcher === "*";
+    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 && interpreterAvailable(relay.executable, env) && isThisScript(relay.relay);
+      }));
+  } catch {
+    return false;
+  }
+}
+
+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);
+  return settingsRelayReports(hookEvent, providerPayload, env);
+}
+
+// --- seat project boundary: keep this block identical in every script that has it ---
+// A Claude started from inside a seat (its shell, its Bash tool) inherits the seat's environment, so it loads this plugin
+// and its hooks would act as the seat. OpenRig tells the plugin the seat's launch project in OPENRIG_SEAT_PROJECT_DIR;
+// Claude's own CLAUDE_PROJECT_DIR is fixed for the life of a Claude and names the project it was started in (unlike the
+// hook payload's cwd, which follows a `cd`). The seat's effects run only when the two name the same folder. Spellings of
+// one folder (a symlink, a trailing slash, letter case on a case-insensitive disk) count as the same, and a missing
+// variable (an older or manual launch, a runtime without CLAUDE_PROJECT_DIR) leaves the hook doing what it always did.
+function runsForThisSeatsProject(env = process.env) {
+  const launch = env.OPENRIG_SEAT_PROJECT_DIR;
+  const project = env.CLAUDE_PROJECT_DIR;
+  if (!launch || !project) return true;
+  const canonical = (dir) => {
+    const absolute = path.resolve(dir);
+    // .native gives the case the disk has (plain realpathSync keeps the case the path was typed in), which is what Claude's
+    // CLAUDE_PROJECT_DIR carries on a case-insensitive filesystem such as macOS's default.
+    try { return fs.realpathSync.native(absolute); } catch { return absolute; }
+  };
+  return canonical(launch) === canonical(project);
+}
+// --- end seat project boundary ---
+
 async function main() {
+  // Before anything is read, posted or recorded: a Claude started elsewhere inside this seat is not the seat.
+  if (!runsForThisSeatsProject()) return;
   const providerPayload = parseJson(await readStdin());
+  if (pluginRunIsRedundant(providerPayload)) return;
   const payload = buildOpenRigPayload(providerPayload);
   const identityPayload = buildSessionIdentityPayload(providerPayload, process.env);
   if (identityPayload && identityPayload.resumeLaunch) {
@@ -229,4 +319,7 @@ module.exports = {
   parseJson,
   postHookPayload,
   resolveEndpoint,
+  pluginRunIsRedundant,
+  settingsRelayReports,
+  settingsRelayPath,
 };

package/daemon/assets/plugins/openrig-core/hooks/scripts/compaction-restore-bridge.cjs

@@ -177,7 +177,30 @@ function hookEventName(payload) {
   ) || "UserPromptSubmit";
 }
 
+// --- seat project boundary: keep this block identical in every script that has it ---
+// A Claude started from inside a seat (its shell, its Bash tool) inherits the seat's environment, so it loads this plugin
+// and its hooks would act as the seat. OpenRig tells the plugin the seat's launch project in OPENRIG_SEAT_PROJECT_DIR;
+// Claude's own CLAUDE_PROJECT_DIR is fixed for the life of a Claude and names the project it was started in (unlike the
+// hook payload's cwd, which follows a `cd`). The seat's effects run only when the two name the same folder. Spellings of
+// one folder (a symlink, a trailing slash, letter case on a case-insensitive disk) count as the same, and a missing
+// variable (an older or manual launch, a runtime without CLAUDE_PROJECT_DIR) leaves the hook doing what it always did.
+function runsForThisSeatsProject(env = process.env) {
+  const launch = env.OPENRIG_SEAT_PROJECT_DIR;
+  const project = env.CLAUDE_PROJECT_DIR;
+  if (!launch || !project) return true;
+  const canonical = (dir) => {
+    const absolute = path.resolve(dir);
+    // .native gives the case the disk has (plain realpathSync keeps the case the path was typed in), which is what Claude's
+    // CLAUDE_PROJECT_DIR carries on a case-insensitive filesystem such as macOS's default.
+    try { return fs.realpathSync.native(absolute); } catch { return absolute; }
+  };
+  return canonical(launch) === canonical(project);
+}
+// --- end seat project boundary ---
+
 async function main() {
+  // A Claude started elsewhere inside this seat is not the seat: leave its markers alone.
+  if (!runsForThisSeatsProject()) return;
   const payload = parseJson(await readStdin());
   const eventName = hookEventName(payload);
   const marker = findMarker(payload);

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

@@ -6,7 +6,9 @@ const { spawnSync } = require("node:child_process");
 
 // One issue per failure episode, after three unsuccessful attempts. Retrying an
 // uncertain stream write uses the same id; a successful delivery starts afresh.
-function recordRefocusResult({ home, seat, identity, failed }) {
+// `deadlineMs` is when the caller must be done, counted from process start: the
+// report gets up to 1.5 s of what is left before it.
+function recordRefocusResult({ home, seat, identity, failed, deadlineMs = 4_500 }) {
   if (!seat || !identity) return;
   const key = crypto.createHash("sha256").update(JSON.stringify([seat, identity])).digest("hex");
   const file = path.join(home, "refocus", `${key}.health.json`);
@@ -26,7 +28,7 @@ function recordRefocusResult({ home, seat, identity, failed }) {
       "--hint-type", "issue", "--hint-tags", "issue,refocus",
       "--body", `Refocus failed on ${state.failures} consecutive attempts for ${seat}. Orientation remains unverified; inspect this seat's refocus hook diagnostics.`,
       "--json",
-    ], { encoding: "utf8", timeout: Math.max(1, Math.min(1_500, 4_500 - Math.floor(process.uptime() * 1_000))), maxBuffer: 64 * 1024, env: process.env });
+    ], { encoding: "utf8", timeout: Math.max(1, Math.min(1_500, deadlineMs - Math.floor(process.uptime() * 1_000))), maxBuffer: 64 * 1024, env: process.env });
     if (!result.error && result.status === 0) {
       state.reportedAt = new Date().toISOString();
       fs.writeFileSync(file, JSON.stringify(state), { mode: 0o600 });

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

@@ -15,7 +15,28 @@ const { recordRefocusResult } = require("./refocus-health.cjs");
 
 const DEFAULT_THRESHOLD = 2_600_000;
 const FALSE_VALUES = new Set(["0", "false", "off", "no"]);
-const CONTENT_LOOKUP_TIMEOUT_MS = 2_000;
+// The issue report after a failed attempt gets this long once the attempt's lookups are done.
+const REPORT_MS = 1_500;
+// 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
+// leaves an honest gap and the hook still ends well inside the outer bound.
+const DEFAULT_BUDGET_MS = 4_500;
+const MAX_BUDGET_MS = 52_000;
+const BUDGET_MS = (() => {
+  const value = Number(process.env.OPENRIG_REFOCUS_BUDGET_MS);
+  return Number.isFinite(value) && value > DEFAULT_BUDGET_MS ? Math.min(value, MAX_BUDGET_MS) : DEFAULT_BUDGET_MS;
+})();
+const SELECTED_BUDGET = BUDGET_MS !== DEFAULT_BUDGET_MS;
+const LOOKUP_CAP_MS = Math.round(2_000 * BUDGET_MS / DEFAULT_BUDGET_MS);
+const CONTENT_LOOKUP_TIMEOUT_MS = LOOKUP_CAP_MS;
+// With a selected budget, a lookup with less than this left is skipped and reported as a gap rather than started.
+const MIN_LOOKUP_MS = 250;
+const budgetLeftMs = () => Math.floor(BUDGET_MS - process.uptime() * 1_000);
+const contentReserveMs = () => (process.env.OPENRIG_REFOCUS_CONTENT_REF ? CONTENT_LOOKUP_TIMEOUT_MS : 0);
+// A lookup's timeout: its fixed cap by default; with a selected budget, its cap or what's left of the budget after the
+// later lookups' reserve, whichever is less.
+const lookupTimeout = (reserve = 0) => SELECTED_BUDGET ? Math.min(LOOKUP_CAP_MS, budgetLeftMs() - reserve) : LOOKUP_CAP_MS;
 // Normal managed restore advances on ~30 s polls with a 10 s idle wait.
 // A lost daemon stage must not suppress this occupant's refocus indefinitely.
 const MANAGED_RESTORE_HOLD_MS = 10 * 60_000;
@@ -46,10 +67,12 @@ const readStdin = () => new Promise((resolve) => {
 function readConfiguredContent(home) {
   const contentRef = process.env.OPENRIG_REFOCUS_CONTENT_REF || "";
   if (contentRef) {
+    const timeout = lookupTimeout();
+    if (timeout <= MIN_LOOKUP_MS) return { content: null, contentRef, failure: "no time left in the refocus budget" };
     const result = spawnSync("rig", ["context", "get", contentRef], {
       encoding: "utf8",
       env: process.env,
-      timeout: CONTENT_LOOKUP_TIMEOUT_MS,
+      timeout,
       maxBuffer: 16 * 1024 * 1024,
     });
     if (!result.error && result.status === 0 && result.stdout.trim()) {
@@ -102,14 +125,18 @@ 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 = 2_000) {
+function readQueueWhoami(timeout = lookupTimeout()) {
+  if (timeout <= MIN_LOOKUP_MS) return { unknown: "no time left in the refocus budget" };
   const args = ["queue", "whoami", "--json", ...(workPacketEnabled() ? ["--work-candidates"] : [])];
   let result = spawnSync("rig", args, {
     encoding: "utf8", env: process.env, timeout, maxBuffer: 16 * 1024 * 1024,
@@ -147,7 +174,7 @@ function deriveWorkStart(lookup) {
 // retrying here would spend the same budget twice and cannot make absence trustworthy.
 function remainingLookupBudget() {
   const contentReserve = process.env.OPENRIG_REFOCUS_CONTENT_REF ? CONTENT_LOOKUP_TIMEOUT_MS : 0;
-  return Math.floor(Math.min(2_000, 4_500 - 2_000 - contentReserve - process.uptime() * 1_000));
+  return Math.floor(Math.min(LOOKUP_CAP_MS, BUDGET_MS - LOOKUP_CAP_MS - contentReserve - process.uptime() * 1_000));
 }
 
 function renderRole(result) {
@@ -175,10 +202,9 @@ function renderRole(result) {
 // read; a failed, malformed or skipped read sets nothing, so the script's own lookup runs
 // exactly as before. Only the two root fields are consumed and nothing from the config is logged.
 //
-// Both harnesses kill this hook at 5 s (hooks/claude.json, hooks/codex.json). The read gets only
-// what is left of a 4.5 s budget, counted from process start, after reserving python's 2 s and,
-// when a content ref is configured, the content lookup that runs after python; with 250 ms or
-// less left it is skipped, so the read never pushes a fire main would deliver past the kill.
+// The read gets only what is left of the hook's budget (4.5 s by default), counted from process
+// start, after reserving python's cap and, when a content ref is configured, the content lookup
+// that runs after python; with 250 ms or less left it is skipped.
 function traceEnv(trees) {
   const env = { ...process.env };
   const missing = [
@@ -249,13 +275,17 @@ function renderTrace() {
   else if (work.unknown) args.push("--work-unknown", work.unknown);
   // With an explicit start, the evidence supplies only held and next work.
   if (explicitStart && evidence) args.push("--work-candidates", "-");
-  const result = spawnSync(process.env.PYTHON || "python3", args, {
-    encoding: "utf8",
-    ...(evidence ? { input: evidence } : {}),
-    env: traceEnv(trees),
-    timeout: 2_000,
-    maxBuffer: 16 * 1024 * 1024,
-  });
+  const env = traceEnv(trees);
+  const timeout = lookupTimeout(contentReserveMs());
+  const result = timeout <= MIN_LOOKUP_MS
+    ? { error: new Error("no time left in the refocus budget"), status: null, stdout: "", stderr: "" }
+    : spawnSync(process.env.PYTHON || "python3", args, {
+      encoding: "utf8",
+      ...(evidence ? { input: evidence } : {}),
+      env,
+      timeout,
+      maxBuffer: 16 * 1024 * 1024,
+    });
   const reason = result.error?.message || result.stderr?.trim() || `trace exited ${result.status ?? "without a status"}`;
   const failed = Boolean(result.error) || result.status !== 0 || !result.stdout?.trim();
   const trace = [
@@ -268,8 +298,31 @@ function renderTrace() {
   };
 }
 
+// --- seat project boundary: keep this block identical in every script that has it ---
+// A Claude started from inside a seat (its shell, its Bash tool) inherits the seat's environment, so it loads this plugin
+// and its hooks would act as the seat. OpenRig tells the plugin the seat's launch project in OPENRIG_SEAT_PROJECT_DIR;
+// Claude's own CLAUDE_PROJECT_DIR is fixed for the life of a Claude and names the project it was started in (unlike the
+// hook payload's cwd, which follows a `cd`). The seat's effects run only when the two name the same folder. Spellings of
+// one folder (a symlink, a trailing slash, letter case on a case-insensitive disk) count as the same, and a missing
+// variable (an older or manual launch, a runtime without CLAUDE_PROJECT_DIR) leaves the hook doing what it always did.
+function runsForThisSeatsProject(env = process.env) {
+  const launch = env.OPENRIG_SEAT_PROJECT_DIR;
+  const project = env.CLAUDE_PROJECT_DIR;
+  if (!launch || !project) return true;
+  const canonical = (dir) => {
+    const absolute = path.resolve(dir);
+    // .native gives the case the disk has (plain realpathSync keeps the case the path was typed in), which is what Claude's
+    // CLAUDE_PROJECT_DIR carries on a case-insensitive filesystem such as macOS's default.
+    try { return fs.realpathSync.native(absolute); } catch { return absolute; }
+  };
+  return canonical(launch) === canonical(project);
+}
+// --- end seat project boundary ---
+
 (async () => {
   if (!enabled(process.env.OPENRIG_REFOCUS_ENABLED)) process.exit(0);
+  // A Claude started elsewhere inside this seat is not the seat: no state, no refocus.
+  if (!runsForThisSeatsProject()) process.exit(0);
 
   let input = {};
   try { input = JSON.parse((await readStdin()) || "{}") || {}; } catch {}
@@ -481,7 +534,10 @@ function renderTrace() {
     },
   });
   process.stdout.write(output, (error) => {
-    recordRefocusResult({ home, seat, identity, failed: failed || Boolean(error) });
+    // The report gets its own window after the attempt's lookups, however long they actually took (default lookups keep
+    // their fixed caps, so a default attempt can run past its 4.5 s budget).
+    recordRefocusResult({ home, seat, identity, failed: failed || Boolean(error),
+      deadlineMs: Math.max(BUDGET_MS, Math.floor(process.uptime() * 1_000)) + REPORT_MS });
     if (failed || error) {
       state.pendingOn ||= event;
       state.pendingAt ||= new Date().toISOString();