@openrig/cli 0.6.4 → 0.6.6

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

@@ -14,6 +14,7 @@ const { spawnSync } = require("node:child_process");
 
 const DEFAULT_THRESHOLD = 2_600_000;
 const FALSE_VALUES = new Set(["0", "false", "off", "no"]);
+const CONTENT_LOOKUP_TIMEOUT_MS = 2_000;
 
 function runtime() {
   const index = process.argv.indexOf("--runtime");
@@ -44,7 +45,7 @@ function readConfiguredContent(home) {
     const result = spawnSync("rig", ["context", "get", contentRef], {
       encoding: "utf8",
       env: process.env,
-      timeout: 2_000,
+      timeout: CONTENT_LOOKUP_TIMEOUT_MS,
       maxBuffer: 16 * 1024 * 1024,
     });
     if (!result.error && result.status === 0 && result.stdout.trim()) {
@@ -93,49 +94,128 @@ function readConfiguredContent(home) {
 
 // A live seat carries no OPENRIG_REFOCUS_WORK_NODE, so the trace used to report an
 // unresolved work node while the daemon could already name the seat's typed baton. Ask it.
-// The explicit variable always wins and short-circuits the call; any failure here returns
-// null and leaves the pre-existing gap line intact, because refusing to answer is correct
-// and guessing a work node would silently re-point the whole trace.
-function deriveWorkStart() {
-  if (process.env.OPENRIG_REFOCUS_WORK_NODE) return process.env.OPENRIG_REFOCUS_WORK_NODE;
+// The explicit variable always wins and short-circuits the call. When the daemon names no
+// 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.
+function readQueueWhoami(timeout = 2_000) {
   const result = spawnSync("rig", ["queue", "whoami", "--json"], {
+    encoding: "utf8", env: process.env, timeout, maxBuffer: 16 * 1024 * 1024,
+  });
+  if (result.error) return { unknown: `queue whoami failed: ${result.error.message}` };
+  if (result.status !== 0 || !result.stdout || !result.stdout.trim()) {
+    return { unknown: `queue whoami exited ${result.status ?? "without a status"} with no answer` };
+  }
+  try { return { answer: JSON.parse(result.stdout) }; }
+  catch { return { unknown: "queue whoami answer was not JSON" }; }
+}
+
+function deriveWorkStart(lookup) {
+  if (process.env.OPENRIG_REFOCUS_WORK_NODE) return { start: process.env.OPENRIG_REFOCUS_WORK_NODE };
+  const result = lookup();
+  if (result.unknown) return result;
+  const workNodePath = result.answer?.currentWork?.workNodePath;
+  if (typeof workNodePath === "string" && workNodePath) return { start: workNodePath };
+  const basis = result.answer?.currentWorkBasis;
+  return typeof basis === "string" && basis ? { basis } : { unknown: "queue whoami named no current work and no basis" };
+}
+
+// One optional lookup shares the trace/config budget. Reuse even a failed work 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));
+}
+
+function renderRole(result) {
+  const unknown = reason => `Role file: unknown (${reason})`;
+  if (result.unknown) return unknown(result.unknown);
+  const role = result.answer?.role;
+  if (!role || !Array.isArray(role.files)) return unknown("queue whoami has no role information");
+  if (role.state === "unknown") return unknown(role.reason || "role observation unavailable");
+  if (role.state === "no-record" || role.state === "not-declared") return `Role file: ${role.state}`;
+  if (!["present", "missing"].includes(role.state) || role.files.length === 0
+    || role.files.some(file => !file || typeof file.resolvedPath !== "string"
+      || !["present", "missing"].includes(file.state))) return unknown("malformed role information");
+  return [
+    ...role.files.map(file => file.state === "present"
+      ? `Your seat's role file: ${JSON.stringify(file.resolvedPath)}. Re-read it if your role is unclear.`
+      : `Role file: missing (${JSON.stringify(file.resolvedPath)})`),
+    `Binding recorded at: ${role.recordedAt || "unknown"}. ${role.note || "Current bytes and successful startup are not verified."}`,
+  ].join("\n");
+}
+
+// The trace script looks up each missing root with its own `rig config get`, two CLI starts
+// inside its 2 s budget. One `rig config --json` read here fills only the roots the selected
+// trees need and that are missing, under the config store's own env names, which the script
+// already honours. An explicit nonempty value is never replaced; nothing missing skips the
+// 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.
+function traceEnv(trees) {
+  const env = { ...process.env };
+  const missing = [
+    ["OPENRIG_TOPOLOGY_ROOT", "topology", "topology"],
+    ["OPENRIG_WORKSPACE_ROOT", "workspace", "work"],
+  ].filter(([name, , tree]) => (trees === "both" || trees === tree) && !env[name]);
+  if (missing.length === 0) return env;
+  const timeout = remainingLookupBudget();
+  if (timeout <= 250) return env;
+  const result = spawnSync("rig", ["config", "--json"], {
     encoding: "utf8",
     env: process.env,
-    timeout: 2_000,
+    timeout,
     maxBuffer: 16 * 1024 * 1024,
   });
-  if (result.error || result.status !== 0 || !result.stdout || !result.stdout.trim()) return null;
-  try {
-    const workNodePath = JSON.parse(result.stdout)?.currentWork?.workNodePath;
-    return typeof workNodePath === "string" && workNodePath ? workNodePath : null;
-  } catch {
-    return null;
+  if (result.error || result.status !== 0) return env;
+  let config;
+  try { config = JSON.parse(result.stdout); } catch { return env; }
+  for (const [name, section] of missing) {
+    const value = config?.[section]?.root;
+    if (typeof value === "string" && value) env[name] = value;
   }
+  return env;
 }
 
 function renderTrace() {
   const script = path.resolve(__dirname, "../../skills/refocusing/scripts/trace-to-root.py");
+  const trees = process.env.OPENRIG_REFOCUS_TREES || "both";
   const args = [
     script,
-    "--trees", process.env.OPENRIG_REFOCUS_TREES || "both",
+    "--trees", trees,
     "--depth", process.env.OPENRIG_REFOCUS_DEPTH || "light",
   ];
   if (process.env.OPENRIG_REFOCUS_TOPOLOGY_NODE) {
     args.push("--topology-start", process.env.OPENRIG_REFOCUS_TOPOLOGY_NODE);
   }
-  const workStart = deriveWorkStart();
-  if (workStart) {
-    args.push("--work-start", workStart);
+  let whoami;
+  const lookup = () => whoami ??= readQueueWhoami();
+  const work = deriveWorkStart(lookup);
+  let role = "";
+  if (trees === "both" || trees === "topology") {
+    if (!whoami) {
+      const timeout = remainingLookupBudget();
+      whoami = timeout > 250 ? readQueueWhoami(timeout) : { unknown: "no budget left" };
+    }
+    role = renderRole(whoami);
   }
+  if (work.start) args.push("--work-start", work.start);
+  else if (work.basis) args.push("--work-basis", work.basis);
+  else if (work.unknown) args.push("--work-unknown", work.unknown);
   const result = spawnSync(process.env.PYTHON || "python3", args, {
     encoding: "utf8",
-    env: process.env,
+    env: traceEnv(trees),
     timeout: 2_000,
     maxBuffer: 16 * 1024 * 1024,
   });
-  if (!result.error && result.status === 0 && result.stdout.trim()) return result.stdout.trim();
   const reason = result.error?.message || result.stderr?.trim() || `trace exited ${result.status ?? "without a status"}`;
-  return `TRACE GAP — ${String(reason).replace(/\s+/g, " ").trim()}`;
+  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");
 }
 
 (async () => {

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