@openrig/cli 0.5.1 → 0.5.3

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

@@ -1,82 +1,39 @@
 # OpenRig Start
 
-You are running inside an OpenRig-managed topology.
+You are running inside an OpenRig-managed topology — a persistent team of agents in separate
+terminals, each with a name and a role, talking to each other directly.
 
-This file is the thin bootstrap overlay, not the full OpenRig manual.
-Use it to recover identity, communicate, and regain context after launch or compaction.
+**This file is deliberately thin.** Its only job is to get you your identity. It is not an
+orientation, and it cannot tell you what your rig is for or what you are supposed to be doing.
 
-When you are unsure which packaged skill applies, start with the global `openrig-skills` index. It routes to every shipped skill in one hop:
-
-- Claude Code: `~/.claude/skills/openrig-skills/SKILL.md`
-- Codex: `~/.agents/skills/openrig-skills/SKILL.md`
-
-For the full OpenRig command surface, load the packaged `openrig-user` skill now.
-If your runtime supports skills, use that mechanism.
-If it does not auto-load skills reliably, read the packaged copy directly from your current project or workspace:
-
-- Claude Code usually sees it under `.claude/skills/openrig-user/SKILL.md`
-- Codex usually sees it under `.agents/skills/openrig-user/SKILL.md`
-
-That skill covers the broader surface, including chatroom, discovery, adopt/bind/attach, lifecycle, specs, bundles, and richer operator workflows.
-
-Your per-session startup guidance also names the process skills for your role and pod.
-Load AND invoke those now, before proceeding with any work, using your runtime's supported skill mechanism.
-This shared overlay is only the common bootstrap floor, not the full operating manual for your seat.
-
-## Working missions and slices (the SDLC)
-
-If your seat works missions or slices, load the packaged `mission-slice-sop` skill BEFORE authoring or building — it teaches the flow the Living Notes UI projects: intent → mini-requirements + proof contract (→ mockups for UI slices) → plan-lock (`rig scope slice approve --scope spec`) → build the locked set → QA visual compare → `rig proof add … --media` drops (the C1 drop verb — never hand-place proof files) → proof-lock (`--scope delivery`).
-
-The conventions themselves (section names, proof-contract format, the two locks, C1 proof headers) live in ONE shipped document: `docs/reference/sdlc-conventions.md` in the repo, materialized at `$OPENRIG_HOME/reference/sdlc-conventions.md` (default `~/.openrig/reference/sdlc-conventions.md`) on an installed package. `rig scope slice create` scaffolds the convention sections for every template kind; `rig scope audit` is the advisory backstop — it records and advises, it never blocks your work.
-
-## Identity
-
-Run this first after launch or compaction to recover your identity:
+## Identity — run this first
 
 ```bash
 rig whoami --json
 ```
 
-This 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. **Treat it as ground truth.**
+A startup overlay can be stale; this one is small precisely so it has less room to be wrong.
 
-## Communication
+Run it again after any compaction, restart or restore — **before** concluding anything about
+where you are or what you were doing. And if a predecessor's transcript looks thin or empty,
+know that transcript capture is unreliable on some runtimes — **little or no output does not
+mean the session was quiet.**
 
-Send a message to a peer:
-```bash
-rig send <session> "message" --verify
-```
+## Reaching a peer
 
-Read a peer's terminal output:
 ```bash
-rig capture <session>
+rig send <session> "message"     # types into their terminal and presses enter
+rig capture <session>            # reads what is on their screen
 ```
 
-Broadcast to all peers in your rig:
-```bash
-rig broadcast --rig <name> "message"
-```
-
-## Secondary Transcript Check
-
-After compaction, recover work from durable artifacts first: the restore map,
-current `MISSION_NOTES.md`, and your owned queue items. Transcript output is a
-secondary check and may be unavailable or incomplete for some runtimes. Little
-or no output does not mean the session was quiet.
+The session name is the address. `rig --help` lists the rest of the surface.
 
-Read recent transcript output:
-```bash
-rig transcript <session> --tail 100
-```
-
-Search transcripts for specific content:
-```bash
-rig transcript <session> --grep "pattern"
-```
+## What this file is not
 
-## After Compaction
+It is not the manual, and these commands are a fraction of what is available.
 
-If you lose context, run `rig whoami --json` immediately. It tells you who you
-are, who your peers are, and how to reach them. Rebuild the work from the
-restore map, current `MISSION_NOTES.md`, and your owned queue items. Use
-`rig transcript` only as a secondary check; if it returns little or nothing,
-do not conclude that the session was quiet.
+**If nobody has walked you through this system, say so rather than inferring it.** What your rig
+is for, how work moves here, and what you are allowed to do are not in this file and are not
+guessable from it — and guessing your way into a rig is how an agent builds the wrong thing
+correctly.

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

@@ -19,6 +19,15 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/refocus.cjs\"",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "UserPromptSubmit": [
@@ -39,6 +48,15 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/refocus.cjs\"",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "PreCompact": [
@@ -61,6 +79,15 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/refocus.cjs\"",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "Stop": [
@@ -72,6 +99,15 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/scripts/refocus.cjs\"",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "Notification": [

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

@@ -9,6 +9,15 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/refocus.cjs\"",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "UserPromptSubmit": [
@@ -20,6 +29,15 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/refocus.cjs\"",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "Stop": [
@@ -31,6 +49,15 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/scripts/refocus.cjs\"",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "PermissionRequest": [

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

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+"use strict";
+// openrig-core REFOCUS hook (OPR.0.5.3.6 — promoted from the lab where it ran
+// live on 6+ seats; the mechanism ships, the CONTENT is configurable).
+//
+// WHY: the moment an agent most needs to reorient is the moment it is least
+// able to choose to. Drift does not feel like drift — it feels like work. So
+// refocus FIRES rather than waits to be invoked.
+//
+// THIS IS ALSO HOW TOPOLOGY CHAIN FILES REACH A RUNNING SEAT. Editing a file
+// under topology.root is not delivery — a running seat reads its config at
+// session start and its context never re-reads disk on its own. This hook is
+// the delivery channel: it injects orientation content at the seat's next
+// hook boundary (SessionStart / UserPromptSubmit / Stop / PostCompact), so a
+// shipped or updated chain file becomes live doctrine without a relaunch.
+//
+// SIGNAL = TRANSCRIPT GROWTH, not turns and not wall-clock. A "turn" is one
+// prompt submission; an agent can burn 200k tokens across fifty tool calls
+// inside ONE turn, so a turn counter is blind to exactly the drift that
+// matters. The JSONL grows monotonically with work done (measured ~8.9 bytes
+// per context token, so ~300k tokens ≈ 2.6MB — rough on purpose; it needs to
+// be monotonic, not exact). Tune with OPENRIG_REFOCUS_BYTES.
+//
+// CONTENT IS CONFIGURABLE, NEVER PROJECT-SPECIFIC IN SOURCE. Resolution:
+//   1. OPENRIG_REFOCUS_CONTENT_REF env — resolved by `rig context get`.
+//   2. OPENRIG_REFOCUS_CONTENT_FILE env — an operator-authored file.
+//   3. $OPENRIG_HOME/refocus/REFOCUS.md — the instance's standing content.
+//   4. The generic three-question orientation below (project-neutral).
+// Project- or mission-specific refocus text belongs in those FILES, on the
+// instance that needs it — it must never be committed here.
+//
+// Fires on: SessionStart (fresh orientation), Stop (catches the long single
+// turn), UserPromptSubmit, and PostCompact on Claude (post-compaction
+// re-orientation; Codex exposes no compact hook — growth+Stop is the coverage
+// there). Silent unless due. A configured REF failure degrades loudly inside
+// the delivered payload; every failure remains non-blocking because a refocus
+// hook must never break a seat's turn.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const THRESH = Number(process.env.OPENRIG_REFOCUS_BYTES || 2_600_000);
+
+const readStdin = () => new Promise((r) => { let d = ""; process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (c) => d += c); process.stdin.on("end", () => r(d)); process.stdin.on("error", () => r("")); });
+
+(async () => {
+  let input = {}; try { input = JSON.parse((await readStdin()) || "{}") || {}; } catch {}
+  const ev = input.hook_event_name || "UserPromptSubmit";
+  const seat = process.env.OPENRIG_SESSION_NAME || "unknown-seat";
+  const home = process.env.OPENRIG_HOME || path.join(process.env.HOME || "/tmp", ".openrig");
+  const tpath = input.transcript_path || input.transcriptPath || "";
+
+  let size = 0; try { size = fs.statSync(tpath).size; } catch {}
+
+  const dir = path.join(home, "refocus");
+  const file = path.join(dir, `${seat.replace(/[^A-Za-z0-9@._-]/g, "_")}.json`);
+  let st = { lastBytes: 0 };
+  try { st = JSON.parse(fs.readFileSync(file, "utf8")) || st; } catch {}
+
+  const grown = size > 0 ? size - (st.lastBytes || 0) : 0;
+  const due = ev === "SessionStart" || ev === "PostCompact" || grown >= THRESH;
+  if (!due) { process.exit(0); } // silent no-op — the common path
+
+  st.lastBytes = size; st.firedAt = new Date().toISOString(); st.firedOn = ev;
+  try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(file, JSON.stringify(st)); } catch {}
+
+  // A library ref wins over file configuration and reuses the public assembler instead of
+  // growing a second resolver inside this hook. REF failures stay visible without blocking
+  // the session boundary; REF-unset follows the folded FILE/default path byte-for-byte.
+  const contentRef = process.env.OPENRIG_REFOCUS_CONTENT_REF || "";
+  let configured = null;
+  let refFailure = null;
+  if (contentRef) {
+    const result = spawnSync("rig", ["context", "get", contentRef], {
+      encoding: "utf8",
+      env: process.env,
+      timeout: 4_000,
+      maxBuffer: 16 * 1024 * 1024,
+    });
+    if (!result.error && result.status === 0 && result.stdout.trim()) {
+      configured = result.stdout;
+    } else {
+      refFailure = result.error?.message
+        || result.stderr?.trim()
+        || result.stdout?.trim()
+        || `rig context get exited ${result.status ?? "without a status"}`;
+      refFailure = String(refFailure).replace(/\s+/g, " ").trim();
+    }
+  } else {
+    // Configurable content: operator file beats instance file beats the generic default.
+    const contentFile = [
+      process.env.OPENRIG_REFOCUS_CONTENT_FILE,
+      path.join(home, "refocus", "REFOCUS.md"),
+    ].filter(Boolean).find((p) => { try { return fs.existsSync(p); } catch { return false; } });
+    if (contentFile) {
+      try { configured = fs.readFileSync(contentFile, "utf8").trim() || null; } catch {}
+    }
+  }
+
+  const why = ev === "SessionStart" ? "fresh session"
+            : ev === "PostCompact" ? "just compacted — your picture is lossy"
+            : `${Math.round(grown / 1e6 * 10) / 10}MB of work since your last refocus`;
+
+  const generic = [
+    `1. What is the person actually trying to get? Not your current task — the outcome.`,
+    `2. Does what you are doing RIGHT NOW move that? If you cannot say what a user gets, stop and say so.`,
+    `3. What have you concluded without opening the file or running the thing?`,
+    ``,
+    `Discomfort on any of these IS the signal — drift feels like work.`,
+    ``,
+    `Your topology context (instance/rig/seat craft and this seat's LEARNED) is one walk away:`,
+    `rig context trace --rig <rig> --seat <seat> --name CRAFT.md — read it, do not recall it.`,
+    `A seat's LEARNED.md is written by previous occupants in the first person: it is evidence`,
+    `about the SEAT, never your own memory.`,
+  ];
+
+  const payload = refFailure ? [
+    `REFOCUS CONTENT REF FAILED: ${contentRef} — ${refFailure}`,
+    ``,
+    `REFOCUS (${why}). Answer briefly, out loud, before your next move:`,
+    ``,
+    ...generic,
+  ] : [
+    `REFOCUS (${why}). Answer briefly, out loud, before your next move:`,
+    ``,
+    ...(contentRef
+      ? [`REFOCUS CONTENT SOURCE: OPENRIG_REFOCUS_CONTENT_REF=${contentRef}`, ``, configured]
+      : configured ? [configured] : generic),
+  ];
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: ev, additionalContext: payload.join("\n") } }));
+})();

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

@@ -92,6 +92,32 @@ restored from packet at <path>; resumed at step <X>
 
 Include the main files you read in full when you make that statement.
 
+9. **REFOCUS BEFORE YOU RESUME — the restore returns your TASK, not your BEARINGS.** Everything
+   above rebuilds *what you were doing*. None of it rebuilds *what the work is for* or *how this
+   rig operates* — those live in the chains, and nothing in steps 1–8 walks them. Invoke the
+   `refocus` skill and do its reads before your next substantive move.
+
+   **Measured 2026-08-13, and this step exists because of it:** a seat completed this protocol
+   faithfully — packet built, narrative read tail-first, read-depth audit reported honestly — and
+   resumed with a perfect picture of its atom and *zero* work-tree context. It had never opened
+   the mission or project nodes, and could only paraphrase the release's intent second-hand from
+   a peer's message. It then produced a technically-correct trace concluding *"I hold nothing"*
+   while holding 18 pending rows. **A restore that returns you to your task without your bearings
+   is how a confidently-wrong agent gets back to work.**
+
+**On the marker and the packet's size (measured across restores, 2026-08):** two realities the restore
+must handle honestly —
+
+- **The per-seat marker (`restore-pending/<session>.json`) is frequently absent** — in five observed
+  restores it was never present. Treat the JSONL rebuild via `restore-from-jsonl.mjs` as the **primary**
+  path, not a fallback: run it regardless of whether a marker exists. (When product-infra reliably writes
+  the marker for tmux-launched seats, it becomes a fast-path upgrade — not a prerequisite that keeps failing.)
+- **The generated transcript can be very large** (measured at ~346k tokens in one restore). Do **not**
+  read it front-to-back or claim to. `restore-instructions.md` declares its token cost up front; default
+  to the **most recent ~50k tokens of unique narrative first** (recency is what a restore needs — the
+  thread that produced the current frontier, not the boot handshake), and go earlier only if a specific
+  question requires it. A restore must leave room for the work it was restored to do.
+
 ## Required Read-Depth Audit
 
 After the first restore pass, audit yourself before continuing.
@@ -101,9 +127,15 @@ After the first restore pass, audit yourself before continuing.
 2. Mark each item as `FULL`, `PARTIAL`, or `NOT_READ`.
 3. You will be given a task where all of these files are required reading in
    order to understand the task.
-4. Do not optimize for token conservation.
-5. Read every `PARTIAL` or `NOT_READ` item in full now.
-6. Report the final read-depth table before doing any substantive task work.
+4. Read `PARTIAL`/`NOT_READ` items in full — but **to a declared budget with a stopping rule**, not
+   unbounded. Prioritize by relevance to the active task; for a large transcript read the most recent
+   unique narrative first (see *If You Just Compacted*), not front-to-back.
+5. **Stop** when either every task-relevant item is `FULL`, or you reach the budget — *a restore that
+   cannot leave room for the work it was restored to do is not a successful restore.* "Read everything,
+   never conserve" has no termination condition; that open-endedness is the bug, not the goal.
+6. Report the final read-depth table **honestly** (`FULL`/`PARTIAL`/`NOT_READ`, each with a reason)
+   before task work. **An honest `PARTIAL` with its reason is a correct outcome, not a failure** — do
+   not claim a completion you did not reach.
 
 ## Guardrails
 

package/daemon/assets/plugins/openrig-core/skills/claude-compaction-restore/scripts/precompact-hook.mjs

@@ -6,12 +6,7 @@ import { spawnSync } from "node:child_process";
 
 const skillRoot = path.resolve(new URL("..", import.meta.url).pathname);
 const restoreScript = path.join(skillRoot, "scripts", "restore-from-jsonl.mjs");
-// P6(C) injectable output-root: the packet base defaults to the shared
-// /tmp/claude-compaction-restore (production), but becomes per-run isolated when the
-// hermetic env-var OPENRIG_COMPACTION_OUT_ROOT is set — so concurrent writers with the
-// same injected clock + sessionId no longer collide on the same `${sessionId}-${stamp}`
-// dir. Mirrors the injectable-clock seam (OPENRIG_TEST_CLOCK_NOW). Empty/absent = /tmp.
-const outRoot = process.env.OPENRIG_COMPACTION_OUT_ROOT || "/tmp/claude-compaction-restore";
+const outRoot = "/tmp/claude-compaction-restore";
 const defaultRestoreInstruction =
   "Read the claude-compaction-restore skill and follow its \"If You Just Compacted\" protocol.";
 
@@ -29,14 +24,6 @@ function getOpenRigHome() {
   return process.env.OPENRIG_HOME || process.env.RIGGED_HOME || path.join(os.homedir(), ".openrig");
 }
 
-// A3-R3 injectable clock (slice 51-01): marker.createdAt defaults to real wall-clock,
-// but becomes deterministic when the shared hermetic env-var OPENRIG_TEST_CLOCK_NOW is
-// set (an ISO instant). Empty/absent = production real-time.
-function nowIso() {
-  const injected = process.env.OPENRIG_TEST_CLOCK_NOW;
-  return typeof injected === "string" && injected.trim().length > 0 ? injected : new Date().toISOString();
-}
-
 function expandInstructionPath(filePath) {
   if (filePath.startsWith("~/")) return path.join(os.homedir(), filePath.slice(2));
   if (filePath.startsWith("${OPENRIG_HOME}/")) {
@@ -54,50 +41,6 @@ function readInstructionFile(filePath) {
   return fs.readFileSync(expanded, "utf8");
 }
 
-// OPR.0.4.1.09 / R5 marker-lifecycle (foreign-content-in-marker face): the hook
-// path must apply the SAME seat-check the daemon enforcer's resolvePostCompactExtra
-// applies (rev1-r2 dcd95bd9), or a FOREIGN seat's global messageFilePath leaks into
-// THIS seat's marker. Parse a WELL-FORMED leading `---` frontmatter for a declared
-// seat (target_seat / seat / session); body text is never scanned; a broken/absent
-// fence is GENERIC (valid for any seat). Byte-mirrors the enforcer regexes.
-function declaredSeatOf(content) {
-  const fm = /^\s*---\s*\n([\s\S]*?)\n---/.exec(content);
-  if (!fm) return null;
-  const m = /^[ \t]*(?:target[_-]?seat|seat|session(?:[_-]?name)?)[ \t]*:[ \t]*["']?([^"'\n#]+?)["']?[ \t]*$/im.exec(fm[1]);
-  return m ? m[1].trim() : null;
-}
-
-function sanitizeSeat(value) {
-  return value.replace(/[^a-zA-Z0-9_.@-]/g, "_");
-}
-
-// Resolve the post-compaction extra FOR THIS SEAT (mirror of the enforcer): (1) prefer
-// a per-seat compaction/post-compact-extra/<seat>.md — no cross-seat contamination
-// possible; (2) fall back to the global ONLY when it does not declare a DIFFERENT seat
-// (a wrong-seat global is REFUSED). Generic/undeclared/configured-but-absent stay
-// allowed. Returns the path to read, or null when nothing valid for this seat.
-function resolveSeatSafeExtraPath(globalFilePathRaw) {
-  const rawSeat = process.env.OPENRIG_SESSION_NAME || process.env.RIGGED_SESSION_NAME || "";
-  const seatKey = rawSeat ? sanitizeSeat(rawSeat) : "";
-  if (seatKey) {
-    const perSeatPath = path.join(getOpenRigHome(), "compaction", "post-compact-extra", `${seatKey}.md`);
-    if (fs.existsSync(perSeatPath)) {
-      const declared = declaredSeatOf(fs.readFileSync(perSeatPath, "utf8"));
-      if (declared && sanitizeSeat(declared) !== seatKey) return null; // wrong-seat per-seat file
-      return perSeatPath;
-    }
-  }
-  const trimmed = (globalFilePathRaw || "").trim();
-  if (!trimmed) return null;
-  const expanded = expandInstructionPath(trimmed);
-  // configured-but-absent: keep the path (an absent file cannot be a wrong-seat leak;
-  // readInstructionFile returns "" so nothing is appended).
-  if (!fs.existsSync(expanded)) return trimmed;
-  const declared = declaredSeatOf(fs.readFileSync(expanded, "utf8"));
-  if (declared && sanitizeSeat(declared) !== seatKey) return null; // foreign-seat global REFUSED
-  return trimmed;
-}
-
 function sessionKey(input) {
   const raw = [
     process.env.OPENRIG_SESSION_NAME,
@@ -115,28 +58,12 @@ function pendingMarkerPath(input) {
   return path.join(getOpenRigHome(), "compaction", "restore-pending", `${sessionKey(input)}.json`);
 }
 
-// R5 absent-when-needed: drop a lightweight EXPECTED sentinel FIRST (before the packet is
-// generated + the marker is written), carrying the SAME identity binding the marker gets.
-// Its presence-without-a-marker is what lets the bridge be LOUD about a missing packet
-// (hook died partway / write failed); policy off = no hook = no sentinel = silent.
-function writeExpectedSentinel(input) {
-  const p = path.join(getOpenRigHome(), "compaction", "restore-pending", `${sessionKey(input)}.expected.json`);
-  fs.mkdirSync(path.dirname(p), { recursive: true });
-  fs.writeFileSync(p, `${JSON.stringify({
-    version: 1,
-    sessionName: process.env.OPENRIG_SESSION_NAME || process.env.RIGGED_SESSION_NAME || null,
-    sessionId: input.session_id || input.sessionId || null,
-    transcriptPath: input.transcript_path || null,
-    createdAt: nowIso(),
-  }, null, 2)}\n`, "utf8");
-}
-
 function writePendingRestoreMarker(input, parsed, restoreInstruction, customMessage) {
   const markerPath = pendingMarkerPath(input);
   fs.mkdirSync(path.dirname(markerPath), { recursive: true });
   const payload = {
     version: 1,
-    createdAt: nowIso(),
+    createdAt: new Date().toISOString(),
     sessionName: process.env.OPENRIG_SESSION_NAME || process.env.RIGGED_SESSION_NAME || null,
     sessionId: input.session_id || input.sessionId || null,
     transcriptPath: input.transcript_path || null,
@@ -191,18 +118,13 @@ function readClaudeCompactionMessage() {
     parts.push(`Inline restore instruction:\n${inline}`);
   }
   if (filePath && filePath.length > 0) {
-    // R5 seat-check: resolve to the per-seat extra or a seat-safe global; a
-    // foreign-seat global resolves to null and is never injected into this marker.
-    const resolved = resolveSeatSafeExtraPath(filePath);
-    if (resolved) {
-      try {
-        const fileText = readInstructionFile(resolved);
-        if (fileText) {
-          parts.push(`Additional restore instruction file (${resolved}):\n${fileText}`);
-        }
-      } catch {
-        // Keep any inline instruction; unreadable extra files degrade quietly.
+    try {
+      const fileText = readInstructionFile(filePath);
+      if (fileText) {
+        parts.push(`Additional restore instruction file (${filePath}):\n${fileText}`);
       }
+    } catch {
+      // Keep any inline instruction; unreadable extra files degrade quietly.
     }
   }
   if (parts.length > 0) return parts.join("\n\n");
@@ -218,16 +140,7 @@ function buildSystemMessage(restoreInstruction, customMessage) {
 }
 
 try {
-  // Slice 51-01 RIDER (leak-visibility, review-r1 escalation): OPENRIG_TEST_CLOCK_NOW is
-  // read by nowIso() to make createdAt deterministic in tests — but a LEAKED var in a
-  // real seat would silently FREEZE production createdAt. Announce loudly on stderr when
-  // active so any leak is visible in seat logs; absence stays silent (production path).
-  // MUST stay byte-identical to STUB_CLOCK_ANNOUNCEMENT in stub-runner.ts.
-  if (typeof process.env.OPENRIG_TEST_CLOCK_NOW === "string" && process.env.OPENRIG_TEST_CLOCK_NOW.trim().length > 0) {
-    process.stderr.write("OPENRIG_TEST_CLOCK_NOW active — timestamps are injected\n");
-  }
   const input = readHookInput();
-  writeExpectedSentinel(input); // R5: sentinel FIRST, before the packet + marker (catches hook-died-partway)
   const args = [restoreScript, "--out", outRoot, "--json"];
   if (input.cwd) args.push("--cwd", input.cwd);
   if (input.transcript_path && input.transcript_path.endsWith(".jsonl") && fs.existsSync(input.transcript_path)) {