@openrig/cli 0.6.5 → 0.6.7

package/daemon/assets/onboarding/02-self-and-competent-action.md

@@ -42,6 +42,49 @@ looked like. State scoped absences honestly: “not represented on the surface c
 than a global absence you did not establish. If another seat must act, transfer durable work rather
 than printing a summary and disappearing.
 
+## When you are installing OpenRig for someone
+
+After setup and a working selected login, use `rig daemon start` if stopped. On a fresh instance it also starts the
+kernel, including the operator and advisor. They are part of installation; choosing a project team comes later.
+Keep the kernel for a normal install. `rig daemon start --no-kernel` is for automation or an explicit request to
+omit its startup, including the operator that helps the person start a team.
+Read `rig status` and `rig ps --nodes --rig kernel`: started is not ready. The view may open
+while agents finish starting; report their actual state and use the guide's existing recovery routes when needed.
+Right after OpenRig is installed or started, and whenever the person wants to see their agents or OpenRig again,
+open the OpenRig TUI and operator for them: say so, then run `rig terminal open saved:kernel --window --json` on the
+daemon's desktop. Don't wait for particular words. The command opens a new terminal tab/window using
+installed herdr, otherwise plain tmux; inside Herdr it opens a space there. It preserves existing conversations. The default view
+needs no YAML edit. Below 120 measured columns (or unknown width), show the operator alone first; from 120,
+show dashboard and operator equally side by side. The advisor always has a separate tab or tmux window.
+This applies to Claude-only, Codex-only and mixed kernels.
+Keep the queue worker off the first view and accessible through the TUI. Reuse existing conversations and accounts.
+Inspect the result and visible content using authorized desktop tools, or report that visibility is unconfirmed.
+Herdr is visible only inside a terminal the person can see. Creating a workspace or switching the shared TUI
+to `:terminals` does not open that terminal. A window request or CLI success alone is not visual proof. On a
+desktop, do not finish by showing a table or suggesting a command instead of opening the requested view.
+Only if the window cannot open, `rig tui --shared` is the named dashboard-only fallback, not the operator's
+conversation. Explain the failure and help with the chosen fallback; do not attach in your own terminal.
+Over headless SSH, explain that no visible terminal opened; tell the person to open a new terminal window or
+tab and give one complete connection and attachment command using the current Herdr endpoint, as in the guide.
+No, SSH and headless use are valid background outcomes. If the person chooses a manual operator attachment after
+a failure, find the `operator.agent` row with `rig ps --nodes --rig kernel --json`. Give the exact
+`env -u TMUX tmux attach-session -t '=<canonicalSessionName>'` with the observed name filled in for a new terminal
+on the same host and user (over SSH, connect there first). Ctrl-b, then d detaches without stopping it.
+Ask the person's goal and project folder, then hand them to the ready operator; do not implement the project yourself.
+Find the `operator.agent` row with `rig ps --nodes --rig kernel --json` and use its `canonicalSessionName` with
+`rig send <canonicalSessionName> 'This is the agent that installed OpenRig. The person will answer in your pane. Goal: <goal>. Project folder: <absolute path>.'`,
+or have the person type the goal and folder in the operator's pane. Show where the operator answers and let it
+help them choose a team before any starter launch.
+If the person gives you a goal later, forward it, the folder and constraints with `rig send`; leave implementation
+with the operator's team instead of taking over the work yourself.
+Installation is complete when the operator is ready and the person is talking to it, not merely when the daemon is
+healthy. If they choose to talk later, leave the exact connection step and say that the handoff is still pending.
+
+Read `rig context get reference/getting-started.md#open-the-kernel-conversations` for the commands and manual
+path. Without a working daemon, the same guide is `daemon/docs/reference/getting-started.md` in the installed
+`@openrig/cli` package. Confirm what actually opened; on a headless host or unavailable display, say so and give the
+person the exact connection/attach step. Opening a terminal is not permission to start or reset seats or provision accounts.
+
 ## When you need more
 
 When you need to know what OpenRig can do, run `rig context get onboarding-width`: its
@@ -50,8 +93,9 @@ any one command, `rig <command> --help` on the installed binary is the most curr
 
 When your work belongs to a project, `rig context work-install` lists what this project declares (intent, context
 files, skills). Read the ones your task needs; `--deliver` prints them all. If several projects are declared, it
-stops with `project_required`; `rig context work-install --json` lists their ids. Pick one with `--project <id>`
-rather than guessing.
+picks one by your rig and working directory, and stops with `project_required` only when that leaves more than one;
+`rig context work-install --json` lists their ids. Pick one with `--project <id>` rather than guessing. The selection
+order is in `$OPENRIG_HOME/reference/project-workspace.md`, "Work-install project selection".
 
 If you plan or route work, a project's world pack is worth loading in full. If you build, stay with the outcome you
 were handed and what counts as done. If you are setting up a world pack for your own project,

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

@@ -1,6 +1,6 @@
 {
   "name": "openrig-core",
-  "version": "0.1.3",
+  "version": "0.1.8",
   "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.3",
+  "version": "0.1.8",
   "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/hooks/scripts/refocus-health.cjs

@@ -0,0 +1,41 @@
+"use strict";
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+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 }) {
+  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`);
+  try {
+    let state;
+    try { state = JSON.parse(fs.readFileSync(file, "utf8")); } catch { state = {}; }
+    if (!failed && !state.failures) return;
+    state = failed
+      ? { ...state, failures: Number(state.failures || 0) + 1, issueId: state.issueId || `refocus-${crypto.randomUUID()}` }
+      : { failures: 0 };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    // Persist the id before contacting the daemon, including timeout/unknown outcomes.
+    fs.writeFileSync(file, JSON.stringify(state), { mode: 0o600 });
+    if (state.failures < 3 || state.reportedAt) return;
+    const result = spawnSync("rig", [
+      "stream", "emit", "--source", seat, "--id", state.issueId,
+      "--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 });
+    if (!result.error && result.status === 0) {
+      state.reportedAt = new Date().toISOString();
+      fs.writeFileSync(file, JSON.stringify(state), { mode: 0o600 });
+    } else {
+      process.stderr.write("refocus: issue-stream report unconfirmed; retained for the next failed attempt\n");
+    }
+  } catch (error) {
+    process.stderr.write(`refocus: failure accounting unavailable: ${error.message}\n`);
+  }
+}
+
+module.exports = { recordRefocusResult };

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

@@ -11,10 +11,14 @@ const fs = require("node:fs");
 const path = require("node:path");
 const crypto = require("node:crypto");
 const { spawnSync } = require("node:child_process");
+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;
+// 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;
 
 function runtime() {
   const index = process.argv.indexOf("--runtime");
@@ -188,6 +192,7 @@ function renderTrace() {
     script,
     "--trees", trees,
     "--depth", process.env.OPENRIG_REFOCUS_DEPTH || "light",
+    "--check",
   ];
   if (process.env.OPENRIG_REFOCUS_TOPOLOGY_NODE) {
     args.push("--topology-start", process.env.OPENRIG_REFOCUS_TOPOLOGY_NODE);
@@ -213,9 +218,15 @@ function renderTrace() {
     maxBuffer: 16 * 1024 * 1024,
   });
   const reason = result.error?.message || result.stderr?.trim() || `trace exited ${result.status ?? "without a status"}`;
-  const trace = !result.error && result.status === 0 && result.stdout.trim()
-    ? result.stdout.trim() : `TRACE GAP — ${String(reason).replace(/\s+/g, " ").trim()}`;
-  return [trace, role].filter(Boolean).join("\n\n");
+  const failed = Boolean(result.error) || result.status !== 0 || !result.stdout?.trim();
+  const trace = [
+    ...(failed ? [`TRACE GAP — ${String(reason).replace(/\s+/g, " ").trim()}`] : []),
+    result.stdout?.trim(),
+  ].filter(Boolean).join("\n");
+  return {
+    text: [trace, role].filter(Boolean).join("\n\n"),
+    failed,
+  };
 }
 
 (async () => {
@@ -226,6 +237,16 @@ function renderTrace() {
   const event = input.hook_event_name || "UserPromptSubmit";
   const harness = runtime();
 
+  // The acknowledgement is never an actionable restore turn. The managed
+  // marker below also holds earlier/later peer messages, not just this prompt.
+  const rawPrompt = typeof input.prompt === "string" ? input.prompt.trim() : "";
+  // Claude can wrap a complete submitted message as pasted content. Unwrap only
+  // that envelope; a peer quoting a restore request is still an ordinary prompt.
+  const prompt = harness === "claude"
+    ? (rawPrompt.match(/^<pasted_content id="([^"]+)">\s*([\s\S]*)\s*<\/pasted_content id="\1">$/)?.[2]?.trim() ?? rawPrompt)
+    : rawPrompt;
+  if (event === "UserPromptSubmit" && prompt.startsWith("OpenRig post-compaction turn boundary.")) process.exit(0);
+
   // Fresh-session orientation is the default onboarding pack's job. Even a manually invoked hook must
   // no-op here, so a stale registration cannot corrupt the world install.
   if (event === "SessionStart") process.exit(0);
@@ -311,16 +332,16 @@ function renderTrace() {
     state = { lastBytes: size, baselineAt: new Date().toISOString() };
     persist();
   } else if (size > 0 && size < Number(state.lastBytes || 0)) {
-    // Shrink clears pending and resets the baseline BEFORE due computation. The
-    // reset itself emits no refocus, and a stale pending can never ride through a
-    // reset into a delivery. Advisory once per reset episode: the reset moment is
-    // the dedupe (afterwards lastBytes === size), and the marker records in state.
-    delete state.pendingOn;
-    delete state.pendingAt;
+    // Shrink invalidates growth-based due state, not an exact PostCompact event
+    // awaiting its actionable restore turn.
+    if (state.pendingOn !== "PostCompact") {
+      delete state.pendingOn;
+      delete state.pendingAt;
+    }
     state.lastReset = { at: new Date().toISOString(), fromBytes: Number(state.lastBytes || 0), toBytes: size };
     state.lastBytes = size;
     persist();
-    process.stderr.write(`refocus: transcript shrank for ${seat} — baseline reset, pending cleared\n`);
+    process.stderr.write(`refocus: transcript shrank for ${seat} — baseline reset; PostCompact pending retained if present\n`);
   }
 
   const lastBytes = Number(state.lastBytes || 0);
@@ -334,17 +355,46 @@ function renderTrace() {
   if (!due) process.exit(0);
 
   if (event !== "UserPromptSubmit") {
+    if (event === "PostCompact" && harness === "claude") {
+      // PreCompact records whether THIS compact was initiated by the enforcer.
+      // A manual /compact overwrites the marker with false; other occupants
+      // cannot hold this session. Read the early sentinel first if it survives.
+      state.managedRestorePending = false;
+      for (const suffix of [".expected.json", ".json"]) {
+        try {
+          const marker = JSON.parse(fs.readFileSync(path.join(home, "compaction", "restore-pending", seatKey + suffix), "utf8"));
+          if (marker.sessionName !== seat || (marker.sessionId ? marker.sessionId !== identity : !transcriptPath || marker.transcriptPath !== transcriptPath)) continue;
+          state.managedRestorePending = marker.managedRefocusPending === true;
+          break;
+        } catch {}
+      }
+      if (state.managedRestorePending) state.managedRestorePendingAt = new Date().toISOString();
+      else delete state.managedRestorePendingAt;
+    }
     if (event === "PostCompact" || !state.pendingOn) state.pendingOn = event;
     state.pendingAt ||= new Date().toISOString();
     persist();
     process.exit(0);
   }
 
+  if (harness === "claude" && state.managedRestorePending) {
+    const heldFor = Date.now() - Date.parse(state.managedRestorePendingAt);
+    // Missing/invalid timestamps from older state, or a clock moving backwards,
+    // cannot establish a live hold. No timer or extra turn is created here.
+    if (heldFor >= 0 && heldFor < MANAGED_RESTORE_HOLD_MS
+      && !prompt.startsWith("Please respond to this normal user message now by restoring this Claude session after compaction.")) process.exit(0);
+    delete state.managedRestorePending;
+    delete state.managedRestorePendingAt;
+    persist();
+  }
+
   // Run the public trace before resolving a context ref. Besides keeping the
   // content ladder untouched, this makes `rig context get` the last resolver
   // call and preserves the existing observable ref contract.
-  const trace = renderTrace();
+  const rendered = renderTrace();
+  const trace = rendered.text;
   const configured = readConfiguredContent(home);
+  const failed = rendered.failed || Boolean(configured.failure);
   const why = onDemand
     ? "on demand"
     : state.pendingOn === "PostCompact"
@@ -391,7 +441,14 @@ function renderTrace() {
       additionalContext: payload,
     },
   });
-  process.stdout.write(output, () => {
+  process.stdout.write(output, (error) => {
+    recordRefocusResult({ home, seat, identity, failed: failed || Boolean(error) });
+    if (failed || error) {
+      state.pendingOn ||= event;
+      state.pendingAt ||= new Date().toISOString();
+      persist();
+      return;
+    }
     if (size > 0) state.lastBytes = size;
     state.firedAt = new Date().toISOString();
     state.firedOn = event;

package/daemon/assets/plugins/openrig-core/skills/applying-a-permission-policy/SKILL.md

@@ -23,22 +23,34 @@ to invent tasks, publish work or change another host.
 Reuse an existing explicit choice for these harnesses and this scope from the
 user's onboarding context; do not ask again. Existing rules are configuration,
 not evidence of consent to expand their scope. Preserve them without expansion.
-If the choice is unknown, briefly explain:
-
-> This allows the whole `rig` command family, including starting/stopping agents,
-> changing OpenRig configuration and launching processes. It is not global YOLO
-> or permission to invent work. The scope is your personal settings for this
-> project unless you explicitly choose your user-wide sessions instead.
->
-> Allow your agents to run OpenRig commands without repeated permission prompts?
-> **Yes — recommended** / **No — keep prompts**
-
-- **Yes:** require an actual affirmative answer, then apply the procedure below
-  at that scope for the selected harnesses. Never substitute user-wide rules
-  when project rules are unsupported. Native restrictions still apply.
-- **No:** leave permission settings unchanged and continue with existing prompts.
-- **No answer:** make no settings change, infer no consent and continue with
-  existing prompts. Do not keep asking during this setup.
+
+For a team with no explicit policy, recommend keeping the team default. Claude
+already allows ordinary `rig` commands, project reads and common tests, while
+lifecycle commands ask. Codex already has writable workspace and pod state;
+its `on-request` policy does **not** guarantee lifecycle prompts. Explicit
+policies, seat choices and named Codex profiles keep their existing meaning.
+
+Native restrictions can still prompt for installs, commits, other shell
+commands and writes outside writable roots. With the Claude team default, an
+allow does **not** override lifecycle ask rules: `rig up`, `rig down` and the other listed
+lifecycle commands still ask even after Yes. Do not promise prompt-free operation.
+
+Only offer additional persistent allowances when wanted, for the selected
+project or explicitly user-wide scope, or to adjust an explicit seat policy:
+
+> Remember these selected OpenRig commands in your native settings for this
+> project? This is separate from the team launch default; stricter rules and
+> Claude lifecycle asks remain. **Yes / No — keep the team default**
+
+- **Yes:** require an affirmative answer, then apply the procedure below only
+  at the agreed scope. Do not replace ask/deny rules or substitute user-wide
+  settings when project rules are unsupported.
+- **No / no answer:** leave settings and any existing explicit choice unchanged.
+  With no policy selected, keep it unset; never record `none` to mean keeping
+  the team default. Do not repeat the question during this setup.
+
+A recommendation is not consent. Broader filesystem/network access requires
+its own explicit choice; permission consent is separate from launch approval.
 
 Remember an explicit Yes or No in the existing onboarding/project context the
 agent already reads: choice, harnesses and scope. For Yes, record the exact files
@@ -55,14 +67,20 @@ an answered setup question or ask again for routine steps already authorized.
 
 | Choice | What the agent configures |
 | --- | --- |
-| Keep prompts | Preserve current native settings and handle requests when they arise. |
+| Keep the team default | Leave an unset policy unset and preserve current native settings; Claude lifecycle asks and other native restrictions remain. Preserve any existing explicit choice. |
+| “Prompt for everything” (`none`) | Only on an explicit request, opt out of the team allowances. Native rules still decide each prompt; `none` does not guarantee a prompt for every command. |
 | Remember selected commands | Add native allow rules for the chosen family or narrower verbs, leaving other rules and sandbox settings intact. |
 | Broader permissive operation | Explain filesystem/network exposure and configure only the explicitly selected native mode and compatible launch settings. |
 
-**Allowing the whole `rig` family covers all its verbs**, including lifecycle,
+If repeated approvals later interrupt the work, name the actual commands and
+offer a scoped adjustment then. Keep the existing choice until the person
+accepts a change; do not promise to adjust later and silently leave the burden
+with them. Do not reopen an answered choice for each routine operation.
+
+**A whole-family allow matches all `rig` verbs**, including lifecycle,
 topology/config changes and commands that can launch other processes. It is not
-a read-only grant. Offer narrower prefixes such as `rig ps` or `rig queue list`
-when that better fits the request. Do not widen a choice to arbitrary shell
+a read-only grant, but stricter ask/deny rules still win. Offer narrower prefixes
+such as `rig ps` or `rig queue list` when that better fits the request. Do not widen a choice to arbitrary shell
 execution, an entire interpreter or a generic shell wrapper.
 
 ## Apply the choice for the user
@@ -95,7 +113,9 @@ execution, an entire interpreter or a generic shell wrapper.
    existing conversation loaded it.
 6. Verify an ordinary matching operation twice in the target conversation and
    check that an unrelated command gained no matching rule. Use harmless reads,
-   not destructive probes. Report effective settings and remaining prompts.
+   not destructive probes. Report effective settings, their source and remaining
+   prompts; a command already allowed by the launch default does not prove a new
+   persistent rule loaded.
    A parser match alone does not establish native behavior.
 
 Give the user this short undo: **“Undo the OpenRig command allowances added by

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

@@ -91,11 +91,18 @@ You are about to lose every connection you have built. Spend this turn making th
 1. **Think back before writing.** Walk the session and, through your previous map, the windows before it.
    What were the threads? What did you work out about how the pieces fit? What is unfinished? What did you
    decide, and why? What were you about to be wrong about?
-2. **Write the restore map** in your seat folder, not in scratch (scratch can be cleaned while you are
-   compacted): `<topology root>/rigs/<rig>/seats/<seat>/RESTORE-MAP-<UTC yyyymmdd-hhmm>.md`. Derive the
-   folder from `rig whoami --json` and `rig config get topology.root`. **Run `date -u` for the timestamp and
-   every time you write in the map. Do not estimate times**: an estimated time can land before events it
-   describes, as one did in an early run.
+2. **Write the restore map at the exact path named in OpenRig's preparation request.** Follow that
+   request's completion instructions: use your ordinary file-edit tool to write the named `.tmp` file,
+   with the exact completion marker as its last line, then finish and close it. The daemon publishes
+   the completed map atomically; do not run a shell rename or write the final file incrementally.
+   Do not substitute the seat folder or another map. Managed preparation normally publishes
+   `<launch cwd>/.openrig/compaction/preparation/<session>/<attempt>/RESTORE-MAP.md`; its parent
+   compaction folder ignores itself in Git because maps hold private working context. Unknown or
+   unwritable launch directories retain the instance-home fallback named in the request; it may need
+   permission if outside your working directories. When there is **no named path**, use your durable seat
+   folder instead: `<topology root>/rigs/<rig>/seats/<seat>/RESTORE-MAP-<UTC yyyymmdd-hhmm>.md`, derived
+   from `rig whoami --json` and `rig config get topology.root`. **Run `date -u` for the timestamp and every
+   time you write in the map. Do not estimate times**: an estimated time can land before events it describes.
 3. **Open the map with a summary** of 10 to 20 lines: who you are, what you hold, what mattered in this
    window, what is next and who authorizes it, and any hold in force. **Publish that summary as your seat
    recap** too: save it, plus a line naming the map's path, to a file and run
@@ -144,6 +151,15 @@ already leaves you. The edges are the point.
 
 You have facts without connections. Rebuild the connections before you act on anything.
 
+Use the native read tool for file reads throughout restoration. Load `refocusing`
+and consume the current topology and work trace that actually arrived with the
+restore request; do not rerun Python merely to duplicate it. If no current trace
+arrived, name that delivery gap. A packet pointer, compact summary or truncated
+extract is not a full source read. Read required notes and full sources separately
+and complete the restore steps and read-depth audit below; partial reading does
+not establish completed restoration. The earlier acknowledgement-only boundary
+is not a restore request.
+
 1. **Check for a hold first.** Read the restore request, the per-seat instruction file
    (`<OPENRIG_HOME>/compaction/post-compact-extra/<session>.md`, named by your full session such as
    `dev-impl@my-rig.md`) when it exists, the newest row or message from whoever routes your work, and any hold
@@ -162,8 +178,9 @@ You have facts without connections. Rebuild the connections before you act on an
    `rig context work-install` lists what the project declares (intent, context files, skills), so read the pieces
    your task needs. `--deliver` prints them all; when several projects are declared (`--json` lists the ids), name
    one with `--project <id>`.
-4. **Read your own restore map in full**: the newest `RESTORE-MAP-*.md` in your seat folder, which the
-   compaction summary should name. If it points to an earlier map for context you need, read that too.
+4. **Read your own restore map in full** at the exact path named by the preparation request, restore
+   request or compaction summary. Only when none names a path, look for the newest `RESTORE-MAP-*.md`
+   in your seat folder. If the selected map points to an earlier map for context you need, read that too.
 5. **Read down the map's ranked list** to your class's tier line, reading exactly the parts each entry names.
    Then check every row you hold (`rig queue show <id> --full --json`) and anything that may have changed since
    the map was written: merged PRs, new rows, a new hold. The map records what was true when it was written;

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

@@ -125,6 +125,8 @@ function writeExpectedSentinel(input) {
   fs.mkdirSync(path.dirname(p), { recursive: true });
   fs.writeFileSync(p, `${JSON.stringify({
     version: 1,
+    managedRefocusPending: typeof input.custom_instructions === "string"
+      && input.custom_instructions.trimStart().startsWith("OpenRig managed compaction; wait for the restore request."),
     sessionName: process.env.OPENRIG_SESSION_NAME || process.env.RIGGED_SESSION_NAME || null,
     sessionId: input.session_id || input.sessionId || null,
     transcriptPath: input.transcript_path || null,
@@ -137,6 +139,8 @@ function writePendingRestoreMarker(input, parsed, restoreInstruction, customMess
   fs.mkdirSync(path.dirname(markerPath), { recursive: true });
   const payload = {
     version: 1,
+    managedRefocusPending: typeof input.custom_instructions === "string"
+      && input.custom_instructions.trimStart().startsWith("OpenRig managed compaction; wait for the restore request."),
     createdAt: nowIso(),
     sessionName: process.env.OPENRIG_SESSION_NAME || process.env.RIGGED_SESSION_NAME || null,
     sessionId: input.session_id || input.sessionId || null,

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

@@ -196,7 +196,7 @@ rig whoami --json         # know who you are
 rig send <session> "msg"  # talk to a peer
 rig capture <session>     # see a peer's terminal
 rig transcript <session>  # read a peer's history
-rig down <rigId>          # snapshot and tear down
+rig down <rigId>          # snapshot and stop every agent; check rig ps first, only when asked
 rig up <rig-name>         # restore from snapshot
 ```
 

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

@@ -13,7 +13,7 @@ You're running inside OpenRig. OpenRig ships a set of **skills** — small docum
 
 ## How OpenRig context works (30 seconds)
 
-Skills are **progressive disclosure**: a skill's *name + description* sit in your context ambiently (the "hot tier"); its *body* loads only when you open it. So you don't pre-read everything — you pattern-match a skill's "when" to your moment, then open just that one. This file is the index over the whole shipped set. (For bounded procedures, open `agent-operated-workflows`; for ongoing agent-backed applications, open `agent-operated-software`.)
+Skills are **progressive disclosure**: a skill's *name + description* sit in your context ambiently (the "hot tier"); its *body* loads only when you open it. So you don't pre-read everything — you pattern-match a skill's "when" to your moment, then open just that one. This file recommends skills from the shipped set. (For bounded procedures, open `agent-operated-workflows`; for ongoing agent-backed applications, open `agent-operated-software`.)
 
 Every row below names **how to reach the skill** — already-hot, or an exact load path. No row is a dead end.
 
@@ -43,7 +43,7 @@ shows an operator — `get` is the agent-facing pull.)
 
 ## The index
 
-> Membership rule (`layout.skills[*].edges.length > 0`): every public skill with at least one product edge in the generated edge layout appears exactly once in this index; no other skill appears.
+> Membership rule (`layout.skills[*].edges.length > 0`): this index recommends skills from the public product edges. Optional procedures remain available through `rig context list` without a recommendation here.
 
 ### Always loaded — the universal spine (open its body when its moment hits)
 These are auto-delivered to every rig; their name+description are already in your context. Open the body when the "when" matches.
@@ -57,7 +57,7 @@ These are auto-delivered to every rig; their name+description are already in you
 - **loading-addressable-markdown** — a task names Markdown as `path#h2-slug` or `path#h2-slug/h3-slug` outside the context-pack library.
 - **session-compaction-and-restore** — preparing for, or recovering from, compaction (any runtime). The write- and read-side protocol.
 - **queue-handoff** — you're passing durable work to another seat or ending your turn. The queue is the work ledger, not chat.
-- **refocusing** — a long-running seat may have lost the product outcome, crossed a major boundary, or compacted and needs a fresh path-based trace.
+- **refocusing** — invoke as `refocusing` when a long-running seat may have lost the product outcome, crossed a major boundary, or compacted and needs a fresh path-based trace.
 - **seat-continuity-and-handover** — handing your seat's work across a restart or to another owner.
 - **orienting-to-an-inherited-seat** — you just inherited an existing seat through a planned handover and need to verify its identity, state, and testimony.
 - **retiring-and-inheriting-a-seat** — you're planning a seat transition and need to retire the current occupant into a fresh successor without losing continuity.
@@ -72,7 +72,7 @@ These are auto-delivered to every rig; their name+description are already in you
 These ship in the OpenRig repo and reach a seat when its profile selects them. To use one, select it in your profile's `uses.skills`, or open it directly at `packages/daemon/specs/agents/shared/skills/core/<skill>/SKILL.md`.
 
 - **openrig-software-factory** — a user wants continuing reviewed work: manual/team, queue-only orchestration or an explicit Workflow; add one or two seats to the running starter when useful, with context, ownership, concurrency, spend and permission limits. Load `rig context get skills/core/openrig-software-factory/SKILL.md`.
-- **openrig-architect** — authoring a rig or topology (NOT for changing OpenRig itself — that's `openrig-builder`).
+- **openrig-architect** — authoring a rig or topology (NOT for changing OpenRig itself — that's `developing-openrig`).
 - **openrig-cmux** — driving the `cmux` terminal provider.
 - **openrig-herdr** — opening/managing seat terminals via the default proof-gated provider.
 - **agent-startup-and-context-ingestion** — a seat is booting and ingesting its startup context.
@@ -106,7 +106,6 @@ Product-management craft (load when shaping/reviewing work):
 ### Vendored craft — load when you're coding (ships with upstream provenance)
 General engineering skills OpenRig ships as vendored copies. Open when the task matches; they carry "modified by OpenRig" provenance.
 
-- **test-driven-development** — implementing a feature or bugfix: write the failing test first.
 - **verification-before-completion** — about to claim done / passing / fixed: run the check and read the output first.
 - **systematic-debugging** — debugging: find the root cause before the fix.
 - **agent-browser** — driving a browser (screenshot / screencast) from an agent.

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

@@ -301,7 +301,10 @@ OpenRig v0.3.0 adds `rig agent-image`, `rig context-pack`, `rig workspace`, and
 `rig config init-workspace`. *(0.5.0: the `rig context-pack` alias is retired — the store + compose library is the single `rig context` noun; see "Context packs and paced delivery (0.5.0)".)* It also shifts fresh-user starter guidance toward
 `product-team` for human-directed work and `conveyor` for workflow-oriented
 work. Treat `demo` as legacy/test content unless a task specifically asks for
-the old demo spec.
+the old demo spec. *(0.6.6: the built-in teams are `starter` and `factory`, plus the
+specialist teams `code-review`, `research` and `pm`. `product-team`, `conveyor` and
+`demo` are gone, and `first-project` is starter's old name. `workshop` is a rig
+bundle.)*
 
 OpenRig v0.3.1 adds public package/source surfaces for Plugin Primitive v0,
 Claude Auto-Compaction Policy, migration `040_workflow_specs_diagnostic`,
@@ -327,7 +330,9 @@ before relying on a policy or its default.
 
 Compatibility checks:
 - `rig down` accepts a rig name or id. An ambiguous name matching more than one
-  active rig is refused with matching ids; use the intended id.
+  active rig is refused with matching ids; use the intended id. It ends every
+  agent's session and any work in progress, so check `rig ps --nodes --rig <rig>`
+  and that the person asked; `rig up <rig> --existing` restores it.
 - For queue/view JSON or limit differences, compare the installed command's help,
   the running daemon version and the actual response. A wrapper mismatch is not
   by itself a daemon-health failure, and historical workarounds are not current
@@ -357,8 +362,8 @@ rig start --json             # JSON output for agents
 ```
 
 Framing: `rig start` is the RECOVERY entry point, not the getting-started
-hero. The fresh-user boot hero remains `rig up <starter>` (typically
-`rig up product-team`). Reach for `rig start` after a host reboot, daemon
+hero. The fresh-user boot hero remains `rig up <team>` (typically
+`rig up starter` for a first change, or `rig up factory`). Reach for `rig start` after a host reboot, daemon
 restart, or any "bring my rigs back" moment.
 
 ### `rig reconcile-session` — no-launch adopt of a hand-resumed session

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

@@ -11,20 +11,47 @@ metadata:
 
 # Refocusing
 
+Invoke the skill as `refocusing`, its frontmatter name. OpenRig seeds it in the
+Claude and Codex global skill roots and includes selected plugin skills in managed
+loadouts. Existing externally managed copies remain authoritative. If the harness
+has not discovered it yet, read this installed skill file and run its script directly;
+hook registration alone does not prove native skill discovery.
+
 Refocus preserves a long session's earned expertise while re-grounding it in current intent and
 lived context. It is not a restart, wake, or phase checkpoint.
 
-Run the bundled trace from this skill directory instead of reconstructing the hierarchy from memory:
+During an actionable managed restore, consume the current topology and work trace
+that actually arrived with the request. Do not rerun Python merely to duplicate it.
+If no current trace arrived, name that delivery gap. A packet pointer, compact
+summary or truncated extract is not a full source read. Use the native file-read
+tool for required notes and full sources, and complete the existing restore audit;
+partial file reads do not establish completed refocus or restoration.
+
+For a new trace outside that delivered context, follow the command guidance below.
+Resolve the bundled script's absolute path from the directory of this loaded skill.
+Stay in your current working directory; do not `cd` into the skill directory, which
+can change the inferred work node. Run the trace as **one plain command**, replacing
+the example path with the actual absolute path written out in the tool call:
 
 ```bash
-python3 scripts/trace-to-root.py --trees both --depth light
+python3 "/absolute/path/to/refocusing/scripts/trace-to-root.py" --trees both --depth light
 ```
 
+Do not combine this command with shell variables, environment assignments, command
+substitution, exit-status printing or file-reading loops. Read the named source
+files separately with the native read tool. Combined shell loops or variables can
+require native approval even when the intended operations are read-only; a plain
+command is not a guarantee that approval will never be needed.
+
+For managed compaction, refocus during the restore request or its read-depth
+audit. The earlier acknowledgement-only boundary is not permission to restore.
+
 Use `--trees topology|work|both` to select context domains and `--depth light|full` to control how
 much each node contributes. Light work traces compose `intent:` and name notes; full traces include
 the complete node and notes bodies. The script resolves `topology.root` and `workspace.root` with
-`rig config get`. When a current node cannot be derived, set `OPENRIG_REFOCUS_TOPOLOGY_NODE` or
-`OPENRIG_REFOCUS_WORK_NODE`, or pass the matching `--*-start` option.
+`rig config get`. When a known current node must be supplied, pass `--work-start` or
+`--topology-start` with its literal absolute path in the same plain command. Do not
+substitute the project root for a mission or slice node and claim that mission was traced.
 
 The trace walks the topology and work trees. For the project's own declared context (intent, context files,
 skills), `rig context work-install` lists it; read what the next action needs.