@openrig/cli 0.6.8 → 0.6.10

package/README.md

@@ -42,7 +42,7 @@ To install with Bun instead, run `bun add -g @openrig/cli`. OpenRig still runs o
 
 npm 11 and later can skip that postinstall script and print `npm warn install-scripts` naming `@openrig/cli`. That's expected: the CLI still works, and only the Node.js and SQLite check was skipped. To run it yourself, use `node "$(npm root -g)/@openrig/cli/scripts/check-abi.mjs"`; `rig doctor` checks the Node.js version only.
 
-Choose the working account you already have: **Claude Code, Codex, or both**. Reuse an explicit choice; no second subscription is required. `rig setup --dry-run` previews the broader setup; applying `rig setup` checks both harnesses and installs a missing one, plus Herdr unless declined with `--no-herdr`. On macOS, the installing agent offers Ghostty once. Setup leaves an existing cmux installation alone. It is optional for the [selected-provider path](docs/reference/getting-started.md#choose-your-providers).
+Choose the working account you already have: **Claude Code, Codex, or both**. Reuse an explicit choice; no second subscription is required. `rig setup --dry-run` previews the broader setup; applying `rig setup` checks both harnesses and installs a missing one, plus Herdr unless declined with `--no-herdr`. Pass the choice with `--providers claude` or `--providers codex` so the other reads not selected instead of failed. The one-command install above doesn't know the choice, so it installs and checks both; for one provider, go step by step and run `rig setup --providers <choice>`. On macOS, the installing agent offers Ghostty once. Setup leaves an existing cmux installation alone. It is optional for the [selected-provider path](docs/reference/getting-started.md#choose-your-providers).
 
 A team seat with no permission policy, per-seat choice or (for Codex) named profile launches with OpenRig's [team default](docs/reference/rig-spec.md#team-launch-defaults): Claude runs ordinary `rig` commands, project reads and common tests without prompting, while lifecycle commands such as `rig up` and `rig down` still ask; Codex also gets the OpenRig workspace and its pod's state directory as writable directories. Before launching, your agent recommends keeping that default, and offers to remember selected OpenRig commands in your native settings only if you want that, at personal project scope unless you explicitly choose user-wide sessions. It is not global YOLO or permission to invent work. On Yes, the agent [adds and verifies native rules](docs/reference/getting-started.md#have-your-agent-configure-permissions); No or no answer keeps the team default and leaves settings unchanged. An existing explicit choice is reused. Say “Undo the OpenRig command allowances added by this setup” to remove only its additions.
 
@@ -447,7 +447,7 @@ Before setup or managed launch, review [what OpenRig changes on your machine](#w
 
 Already-running adopted sessions may need restart before they pick up newly written runtime config.
 
-**For agents:** First ask which available provider(s) the user wants, reusing an explicit choice. Recommend the working account they already have and follow the selected-provider guide above. Offer core setup (`rig setup`) or the fuller workstation path (`rig setup --full`) only when they want those additional tools. Inspect the result with `--json` and use `rig doctor` to finish any remaining machine-specific issues. Then start the daemon if it is stopped, open the OpenRig TUI and operator for them (say so, then run `rig terminal open saved:kernel --window --json`; no commands for the person to copy), and hand the person's goal and project folder to the kernel operator ([installing-agent handoff](docs/reference/getting-started.md#installing-agent-handoff)). Installation is finished when the person is talking to the operator; don't implement the project yourself. When OpenRig itself misbehaves, read [docs/reference/help.md](docs/reference/help.md) (installed agents can run `rig context get help`; the same text is at [openrig.dev/help/agents](https://www.openrig.dev/help/agents)): it covers the next step, known problems, and how to reach the team if you're still stuck.
+**For agents:** First ask which available provider(s) the user wants, reusing an explicit choice, and pass it to setup (`rig setup --providers claude`, `codex` or `both`). Recommend the working account they already have and follow the selected-provider guide above. Offer core setup (`rig setup`) or the fuller workstation path (`rig setup --full`) only when they want those additional tools. Inspect the result with `--json` and use `rig doctor` to finish any remaining machine-specific issues. Starting OpenRig and opening its view are the last steps of installing, not extras, so do them without stopping to ask whether to go on: start the daemon if it is stopped, open the OpenRig TUI and operator for them (say so, then run `rig terminal open saved:kernel --window --json`; no commands for the person to copy), and hand the person's goal and project folder to the kernel operator ([installing-agent handoff](docs/reference/getting-started.md#installing-agent-handoff)). Installation is finished when the person is talking to the operator; don't implement the project yourself. When OpenRig itself misbehaves, read [docs/reference/help.md](docs/reference/help.md) (installed agents can run `rig context get help`; the same text is at [openrig.dev/help/agents](https://www.openrig.dev/help/agents)): it covers the next step, known problems, and how to reach the team if you're still stuck.
 
 ## Comparison with Claude Managed Agents
 

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

@@ -67,9 +67,10 @@ conversation. Explain the failure and help with the chosen fallback; do not atta
 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.
+a failure, find the `operator.agent` row with
+`rig ps --nodes --rig kernel --json --fields logicalId,canonicalSessionName,tmuxAttachCommand`. Give `env -u TMUX` followed by
+that row's `tmuxAttachCommand`, exactly as listed (it names the daemon's tmux server when that isn't the default
+one), 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>.'`,

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

@@ -1,6 +1,6 @@
 {
   "name": "openrig-core",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "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.8",
+  "version": "0.1.9",
   "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/activity-relay.cjs

@@ -1,6 +1,11 @@
 #!/usr/bin/env node
 "use strict";
 
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
 // OpenRig activity-relay hook script.
 // Reads a hook event payload from stdin, normalizes it, and POSTs to the
 // OpenRig daemon's /api/activity/hooks endpoint for real-time UI seat-status.
@@ -154,6 +159,13 @@ function buildSessionIdentityPayload(providerPayload, env = process.env, now = (
   const sessionName = firstString(env.OPENRIG_SESSION_NAME, env.RIGGED_SESSION_NAME);
   const nodeId = firstString(env.OPENRIG_NODE_ID, env.RIGGED_NODE_ID);
   const runtime = firstString(env.OPENRIG_RUNTIME, env.RIGGED_RUNTIME);
+  const generation = firstString(env.OPENRIG_OCCUPANT_GENERATION, env.RIGGED_OCCUPANT_GENERATION);
+  // How this session began (startup, resume, clear or compact). The daemon tells a resumed
+  // conversation's new id from a /clear by it; it is absent from runtimes that do not report it.
+  const source = firstString(providerPayload.source);
+  // Set only on the command OpenRig sends to resume this seat, so the daemon can tell the process
+  // it launched from another Claude sharing the seat's environment.
+  const resumeLaunch = firstString(env.OPENRIG_RESUME_LAUNCH);
 
   if ((!sessionName && !nodeId) || !runtime) return null;
 
@@ -162,18 +174,45 @@ function buildSessionIdentityPayload(providerPayload, env = process.env, now = (
     sessionName,
     nodeId,
     runtime,
+    generation,
     hookEvent,
+    source,
+    resumeLaunch,
+    // The daemon finds the Claude that ran this hook from its parent chain.
+    hookPid: process.pid,
     sessionId,
     occurredAt: now().toISOString(),
   };
 }
 
+// #1077 — whether this is the first SessionStart of the launch OpenRig armed (OPENRIG_RESUME_LAUNCH
+// for this occupant generation). Recorded on local disk before anything is posted, so a first hook
+// whose post never reaches the daemon still makes every later one (an in-process /resume, a child
+// sharing the environment) report false. Any error reports false.
+function claimFirstLaunchHook(resumeLaunch, generation, dir = path.join(os.tmpdir(), `openrig-resume-launch-${uid()}`)) {
+  if (!resumeLaunch || !generation) return false;
+  try {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const key = crypto.createHash("sha256").update(`${generation}\0${resumeLaunch}`).digest("hex");
+    fs.closeSync(fs.openSync(path.join(dir, key), "wx", 0o600));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function uid() {
+  try { return typeof process.getuid === "function" ? String(process.getuid()) : "user"; } catch { return "user"; }
+}
+
 async function main() {
   const providerPayload = parseJson(await readStdin());
   const payload = buildOpenRigPayload(providerPayload);
-  await postHookPayload(payload);
-
   const identityPayload = buildSessionIdentityPayload(providerPayload, process.env);
+  if (identityPayload && identityPayload.resumeLaunch) {
+    identityPayload.resumeLaunchFirst = claimFirstLaunchHook(identityPayload.resumeLaunch, identityPayload.generation);
+  }
+  await postHookPayload(payload);
   if (identityPayload) {
     await postHookPayload(identityPayload);
   }
@@ -185,6 +224,7 @@ if (require.main === module) {
 
 module.exports = {
   buildOpenRigPayload,
+  claimFirstLaunchHook,
   buildSessionIdentityPayload,
   parseJson,
   postHookPayload,

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

@@ -102,10 +102,29 @@ 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.
+function workPacketEnabled() {
+  return enabled(process.env.OPENRIG_REFOCUS_WORK_PACKET, false);
+}
+
 function readQueueWhoami(timeout = 2_000) {
-  const result = spawnSync("rig", ["queue", "whoami", "--json"], {
+  const args = ["queue", "whoami", "--json", ...(workPacketEnabled() ? ["--work-candidates"] : [])];
+  let result = spawnSync("rig", args, {
     encoding: "utf8", env: process.env, timeout, maxBuffer: 16 * 1024 * 1024,
   });
+  // A rig CLI older than this hook rejects the flag. Ask again without it, inside what is left of
+  // the budget, so the role and the strict answer still arrive (just without candidates).
+  if (args.includes("--work-candidates") && !result.error && result.status !== 0
+    && /unknown option/i.test(`${result.stderr || ""}${result.stdout || ""}`)) {
+    const remaining = remainingLookupBudget();
+    if (remaining > 250) {
+      result = spawnSync("rig", ["queue", "whoami", "--json"], {
+        encoding: "utf8", env: process.env, timeout: remaining, 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` };
@@ -208,11 +227,31 @@ function renderTrace() {
     }
     role = renderRole(whoami);
   }
-  if (work.start) args.push("--work-start", work.start);
+  const packet = workPacketEnabled();
+  let evidence = null;
+  if (packet) {
+    args.push("--packet");
+    if (trees !== "topology") {
+      if (!whoami) {
+        const timeout = remainingLookupBudget();
+        whoami = timeout > 250 ? readQueueWhoami(timeout) : { unknown: "no budget left" };
+      }
+      const candidates = whoami.answer?.workCandidates;
+      if (candidates && typeof candidates === "object") evidence = JSON.stringify(candidates);
+    }
+  }
+  // An explicit start always wins. Otherwise the candidates replace the strict answer: the
+  // strict node ignores mission-only rows, so it could hide a second mission in flight.
+  const explicitStart = Boolean(process.env.OPENRIG_REFOCUS_WORK_NODE);
+  if (work.start && (explicitStart || !evidence)) args.push("--work-start", work.start);
+  else if (evidence) args.push("--work-candidates", "-");
   else if (work.basis) args.push("--work-basis", work.basis);
   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,

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

@@ -104,10 +104,18 @@ a JSON array of 1–4 questions, each
 options (labels up to 75 characters, at most one recommended). Slack shows each
 question as a row of buttons. Each click records that answer on the item, and
 the decision resolves once every question has one. You then receive one reply
-row listing the answers, and the item's `humanAnswers` holds the option ids. The
-human may instead type a reply in the thread; that resolves the decision as
-usual, so read the reply rather than assuming an option was picked. Keep the
-brief complete: the questions add buttons, they do not replace the explanation.
+row listing the answers. In `humanAnswers`, clicked answers are option-id strings.
+A whole typed reply is an object:
+`{kind: "typed-reply", text: "…", placement: "first-unanswered", unansweredCount: N}`.
+It is placed automatically under the first unanswered question; the person did
+not select that question. `N` counts the other question slots still empty in
+`humanAnswers` after that placement.
+Earlier button answers stay intact. Read `text` as the person's words, never as
+an option id even if the strings match. The typed reply still closes the decision
+with the other questions unanswered; `done` is not approval. If every button
+answer was already recorded, that final answer set stays intact and the typed
+reply remains in its correlated reply row. Keep the brief complete: the questions
+add buttons, they do not replace the explanation.
 
 If an existing agent-owned row must wait for a **decision**, block it on the **new live qitem ID**
 (`rig queue block <work-id> --on <human-qitem-id> ...`), not on the human address.

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

@@ -1302,7 +1302,7 @@ Node-granular managed partial restore (v0.3.4+):
 ### Add a member to an existing pod — v0.3.3+
 
 ```bash
-rig add <rig-id> <pod-namespace> <member-fragment-path> [--json]
+rig add <rig> <pod-namespace> <member-fragment-path> [--json]
 ```
 
 `rig add` is the top-level verb for the `add_member` converge op. It adds a
@@ -1310,6 +1310,12 @@ single member to an existing pod from a YAML/JSON member fragment file. The
 daemon resolves the named pod, validates the member, runs preflight, and
 launches the member in place.
 
+`<rig>` is the rig id or its exact name (the `rigName` that `rig whoami --json`
+reports). A name shared by more than one rig is refused before anything is
+added, with the matching ids listed (`rig_ambiguous` under `--json`). `rig add`
+always targets the local daemon: while a remote host is selected it refuses to
+resolve a name (`remote_host_selected`); an exact local id still works.
+
 HTTP outcomes:
 - `201` — member added; per-node launch state included in the response.
 - `400` — `validation_failed` or `preflight_failed` (the fragment or its launch posture is rejected before any state change).

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

@@ -2,10 +2,12 @@
 """Render topology and work context by ascending directory paths only."""
 
 import argparse
+import datetime
 import json
 import os
 import re
 import subprocess
+import sys
 from pathlib import Path
 
 SHELVES = {"rigs", "pods", "seats", "missions", "slices"}
@@ -148,7 +150,82 @@ def light_learned(text):
     return body[:boundary if boundary > 0 else 800].rstrip() + "\n[… use --depth full for the rest]"
 
 
-def render_topology(start, root, depth, failures):
+# OPR.0.7.0.12 — the refocus packet (--packet). Duties and notes are carried as text by
+# conventional section, with an honest "not found" and a bounded excerpt otherwise; nobody is
+# asked to add headings. Old files are named with their measured age as a cue, not a verdict.
+DUTY_HEADINGS = ("my job here", "standing duties")
+NOTES_STATE_HEADINGS = ("current state",)
+HEADING = re.compile(r"^(#{1,6})\s+(.*?)\s*#*\s*$")
+DEFAULT_NOTES_MAX_AGE_DAYS = 14
+
+
+def heading_sections(text, wanted):
+    """[(title, body)] for each Markdown heading whose title starts with a wanted phrase."""
+    lines = re.sub(r"^---\s*\n.*?\n---\s*\n", "", text or "", count=1, flags=re.S).splitlines()
+    found = []
+    for index, line in enumerate(lines):
+        match = HEADING.match(line)
+        if not match or not match.group(2).strip().lower().startswith(wanted):
+            continue
+        level = len(match.group(1))
+        body = []
+        for later in lines[index + 1:]:
+            heading = HEADING.match(later)
+            if heading and len(heading.group(1)) <= level:
+                break
+            body.append(later)
+        found.append((match.group(2).strip(), "\n".join(body).strip()))
+    return found
+
+
+def by_section(text, wanted, path):
+    found = heading_sections(text, wanted)
+    shown = "\n\n".join(f"{title}\n{body}" if body else title for title, body in found)
+    missing = [phrase for phrase in wanted if not any(title.lower().startswith(phrase) for title, _ in found)]
+    if not missing:
+        return shown
+    if not found:
+        names = " or ".join(f'"{phrase.upper()}"' for phrase in wanted)
+        return f"SECTION NOT FOUND — no {names} heading in {path}; bounded excerpt follows\n{light_learned(text)}"
+    # Some sections matched: name each one that did not, with the same bounded excerpt, so text
+    # kept under another heading is not silently dropped.
+    names = ", ".join(f'"{phrase.upper()}"' for phrase in missing)
+    return f"{shown}\n\nSECTION NOT FOUND — no {names} heading in {path}; bounded excerpt follows\n{light_learned(text)}"
+
+
+def notes_max_age_days():
+    try:
+        value = float(os.environ.get("OPENRIG_REFOCUS_NOTES_MAX_AGE_DAYS", DEFAULT_NOTES_MAX_AGE_DAYS))
+    except ValueError:
+        return DEFAULT_NOTES_MAX_AGE_DAYS
+    return value if value > 0 else DEFAULT_NOTES_MAX_AGE_DAYS
+
+
+def age_cue(path, text):
+    """An OLD NOTES line when the file is past the threshold, measured from `updated:` or mtime."""
+    threshold = notes_max_age_days()
+    updated, source = None, "mtime"
+    match = re.match(r"^---\s*\n(.*?)\n---", text or "", re.S)
+    if match:
+        found = re.search(r"^updated:\s*[\"']?(\d{4}-\d{2}-\d{2})", match.group(1), re.M)
+        if found:
+            try:
+                updated = datetime.datetime.strptime(found.group(1), "%Y-%m-%d").replace(tzinfo=datetime.timezone.utc)
+                source = "updated"
+            except ValueError:
+                updated = None
+    if updated is None:
+        try:
+            updated = datetime.datetime.fromtimestamp(path.stat().st_mtime, datetime.timezone.utc)
+        except OSError:
+            return None
+    age = (datetime.datetime.now(datetime.timezone.utc) - updated).total_seconds() / 86400
+    if age <= threshold:
+        return None
+    return f"OLD NOTES — {path}, {age:.0f} days old, source {source}, threshold {threshold:g} days"
+
+
+def render_topology(start, root, depth, failures, packet=False):
     output = ["## TOPOLOGY TRACE", f"root: {root}", f"start: {start}"]
     nodes, error = ascent(start, root)
     if error:
@@ -161,12 +238,21 @@ def render_topology(start, root, depth, failures):
         if text is None:
             output.append(f"\n### {label}\nMISSING LINK — {chain_file}")
             continue
-        body = text.strip() if depth == "full" else light_learned(text)
+        if depth == "full":
+            body = text.strip()
+        elif packet and node == nodes[-1]:
+            # The seat's own file: its job and standing duties as text.
+            body = by_section(text, DUTY_HEADINGS, chain_file)
+        else:
+            body = light_learned(text)
         output.append(f"\n### {label} · LEARNED.md\n{body}")
+        cue = age_cue(chain_file, text) if packet else None
+        if cue:
+            output.append(cue)
     return "\n".join(output)
 
 
-def render_work(start, root, depth, failures, fallback=None):
+def render_work(start, root, depth, failures, fallback=None, packet=False):
     output = ["## WORK TRACE", f"root: {root}", f"start: {start}"]
     if fallback:
         output.append(f"FALLBACK — {fallback}")
@@ -201,6 +287,19 @@ def render_work(start, root, depth, failures, fallback=None):
                     output.append(f"NOTES RESOLUTION GAP — resolved {notes_name} became unreadable at {notes_path}")
                 else:
                     output.append(f"\nNOTES · {notes_name}\n{notes_text.strip()}")
+                    cue = age_cue(notes_path, notes_text) if packet else None
+                    if cue:
+                        output.append(cue)
+            elif packet:
+                notes_text = read(notes_path)
+                if notes_text is None:
+                    failures.append(f"unreadable notes: {notes_path}")
+                    output.append(f"NOTES RESOLUTION GAP — resolved {notes_name} became unreadable at {notes_path}")
+                else:
+                    output.append(f"\nNOTES · {notes_name}\n{by_section(notes_text, NOTES_STATE_HEADINGS, notes_path)}")
+                    cue = age_cue(notes_path, notes_text)
+                    if cue:
+                        output.append(cue)
             else:
                 try:
                     size = notes_path.stat().st_size
@@ -211,9 +310,107 @@ def render_work(start, root, depth, failures, fallback=None):
                     output.append(f"NOTES · {notes_name} · {size} bytes · {notes_path}")
         else:
             output.append(f"NOTES GAP — no readable mission notes at {node}")
+
+        # The SDLC convention keeps a node's current delivery state in PROGRESS.md; carry it
+        # as text when present. Its absence is not a gap: many nodes have no PROGRESS.md.
+        progress_path = node / "PROGRESS.md"
+        progress_text = read(progress_path) if packet else None
+        if progress_text is not None:
+            progress_body = progress_text.strip() if depth == "full" else by_section(progress_text, NOTES_STATE_HEADINGS, progress_path)
+            output.append(f"\nPROGRESS · PROGRESS.md\n{progress_body}")
+            cue = age_cue(progress_path, progress_text)
+            if cue:
+                output.append(cue)
+    return "\n".join(output)
+
+
+def candidate_line(candidate):
+    name = candidate.get("mission") or "?"
+    if candidate.get("slice"):
+        name += f" / {candidate['slice']}"
+    intent_text = candidate.get("intent") or "no readable intent"
+    line = f"- {name} — {intent_text} — source: {candidate.get('source') or 'unknown'}"
+    if candidate.get("unresolved"):
+        line += f" — UNRESOLVED ON THIS HOST: {candidate['unresolved']}"
+    return line
+
+
+def render_held_and_next(evidence):
+    output = []
+    held = evidence.get("held") or []
+    if held:
+        output.append("HELD WORK (blocked; this is not next):")
+        for row in held:
+            output.append(f"- {row.get('qitemId') or 'a row'} — {row.get('summary') or 'no summary'} — "
+                          f"blocked on {row.get('blockedOn') or 'unknown'} — "
+                          f"continuation: {row.get('continuation') or 'none recorded'}")
+    following = evidence.get("next") or []
+    if following:
+        output.append("POSSIBLE NEXT WORK (pending; no order implied):")
+        for row in following:
+            missions = ", ".join(row.get("missions") or [])
+            output.append(f"- {row.get('qitemId') or 'a row'} — {row.get('summary') or 'no summary'}"
+                          + (f" [mission: {missions}]" if missions else ""))
+    if evidence.get("heldAndNextTruncated"):
+        output.append("(held and next lists were cut; `rig queue list` has the rest)")
     return "\n".join(output)
 
 
+def render_candidates(evidence, root, depth, failures):
+    """The work section from labelled queue evidence. One direct, resolved tag is shown as the
+    work with its source; anything less certain lists every candidate and asks the agent."""
+    candidates = evidence.get("candidates") or []
+    unknown = evidence.get("unknown") or []
+    if (len(candidates) == 1 and not unknown and candidates[0].get("kind") == "tag"
+            and candidates[0].get("workNodePath") and not candidates[0].get("unresolved")):
+        only = candidates[0]
+        notes = [f"WORK FROM QUEUE EVIDENCE — {only.get('source')}. If this is stale, say what you are actually doing."]
+        if not only.get("slice"):
+            notes.append("no slice named")
+        traced = render_work(Path(only["workNodePath"]), root, depth, failures, packet=True)
+        head, _, rest = traced.partition("\n")
+        return "\n".join([head, *notes, rest])
+
+    missions_root = evidence.get("missionsRoot") or str(root / "missions")
+    output = ["## WORK — name it"]
+    if not candidates and not unknown:
+        output.append("No in-progress queue row names your work. If you are working from messages, "
+                      "name the mission they belong to; if you have no current work, say so.")
+    elif len(candidates) > 1:
+        output.append(f"{len(candidates)} candidates are in flight. Say which mission you are actually working on.")
+    else:
+        output.append("The queue evidence does not settle your work. Confirm a candidate or name your mission.")
+    if candidates:
+        output.append("Candidates (evidence, not a verdict; none is adopted for you):")
+        output.extend(candidate_line(candidate) for candidate in candidates)
+    if unknown:
+        output.append("In-progress rows the queue cannot place:")
+        output.extend(f"- {row.get('qitemId') or 'a row'} — {row.get('summary') or 'no summary'}: {row.get('reason')}"
+                      for row in unknown)
+    if not candidates:
+        names = evidence.get("missionsOnHost") or []
+        if names:
+            listing = ", ".join(names) + (", …" if evidence.get("missionsOnHostTruncated") else "")
+            output.append(f"Missions on this host: {listing}")
+    output.append("Then read that mission's current intent as text:")
+    output.append(f"  python3 {Path(__file__).resolve()} --trees work --packet --work-start {missions_root}/<mission>")
+    orientation = render_work(root, root, "light", failures, packet=True)
+    _, _, rest = orientation.partition("\n")
+    output.append("\n## ORIENTATION — the project-level chain, not your work\n" + rest.lstrip("\n"))
+    return "\n".join(output)
+
+
+def read_candidates(source):
+    try:
+        raw = sys.stdin.read() if source == "-" else Path(source).read_text(encoding="utf8")
+        evidence = json.loads(raw)
+    except (OSError, json.JSONDecodeError) as error:
+        return None, f"work candidates unreadable: {error}"
+    if not isinstance(evidence, dict) or not isinstance(evidence.get("candidates", []), list):
+        return None, "work candidates have an invalid shape"
+    return evidence, None
+
+
 def canonical_seat(session):
     """(member, rig) for a canonical session name, else None so the caller asks `rig whoami`.
 
@@ -279,6 +476,8 @@ def main():
     parser.add_argument("--work-basis", help="the daemon's reason no current work node was named")
     parser.add_argument("--work-unknown", help="why the current work node could not be read")
     parser.add_argument("--check", action="store_true", help="exit nonzero on trace or notes resolution failure; rendered text is unchanged")
+    parser.add_argument("--packet", action="store_true", help="carry duties and notes as text by section, with old-notes cues")
+    parser.add_argument("--work-candidates", help="labelled work evidence as JSON (a path, or - for stdin), from `rig queue whoami --work-candidates`")
     args = parser.parse_args()
 
     sections = []
@@ -293,7 +492,7 @@ def main():
             sections.append(gap("## TOPOLOGY TRACE\nTRACE GAP — topology.root is unresolved"))
         else:
             start = Path(args.topology_start) if args.topology_start else derive_topology_start(root)
-            sections.append(render_topology(start, root, args.depth, failures) if start else
+            sections.append(render_topology(start, root, args.depth, failures, packet=args.packet) if start else
                             gap("## TOPOLOGY TRACE\nTRACE GAP — current topology node is unresolved; pass --topology-start with a literal absolute path (or configure OPENRIG_REFOCUS_TOPOLOGY_NODE separately)"))
 
     if args.trees in {"work", "both"}:
@@ -304,10 +503,19 @@ def main():
             # Precedence: an explicit start wins; then the hook's daemon answer (basis or unknown);
             # only a standalone run with neither falls back to inferring from the working directory.
             explicit = args.work_start or os.environ.get("OPENRIG_REFOCUS_WORK_NODE")
+            evidence = None
+            if args.work_candidates:
+                evidence, error = read_candidates(args.work_candidates)
+                if error:
+                    sections.append(gap(f"## WORK TRACE\nTRACE GAP — {error}"))
             if explicit:
-                sections.append(render_work(Path(explicit), root, args.depth, failures))
+                sections.append(render_work(Path(explicit), root, args.depth, failures, packet=args.packet))
+            elif evidence is not None:
+                sections.append(render_candidates(evidence, root, args.depth, failures))
+            elif args.work_candidates:
+                pass  # the unreadable-evidence gap above is the answer; never fall back to the root
             elif args.work_basis == NO_CURRENT_BATON_BASIS:
-                sections.append(render_work(root, root, args.depth, failures, fallback=(
+                sections.append(render_work(root, root, args.depth, failures, packet=args.packet, fallback=(
                     f"no current typed baton ({args.work_basis}). Showing the project-level chain from the work root: "
                     "a broad orientation, not evidence of a current mission")))
             elif args.work_basis:
@@ -316,8 +524,11 @@ def main():
                 sections.append(gap(f"## WORK TRACE\nTRACE GAP — current work node UNKNOWN: {args.work_unknown}"))
             else:
                 start = derive_work_start(root)
-                sections.append(render_work(start, root, args.depth, failures) if start else
+                sections.append(render_work(start, root, args.depth, failures, packet=args.packet) if start else
                                 gap("## WORK TRACE\nTRACE GAP — current work node is unresolved; pass --work-start with a literal absolute path (or configure OPENRIG_REFOCUS_WORK_NODE separately)"))
+            held_and_next = render_held_and_next(evidence) if evidence else ""
+            if held_and_next:
+                sections.append(held_and_next)
 
     print("\n\n".join(sections))
     return 1 if args.check and failures else 0

package/daemon/assets/skills/rigs/SKILL.md

@@ -68,9 +68,10 @@ guidance in `AGENTS.md` or `CLAUDE.md` plus the team's skills and plugins. Say s
     and ends with `run:` and a command (the `error` field with `--json`). That command already names the installed
     herdr binary and the daemon's socket, or the conversation to attach. Relay it exactly rather than composing one.
     If a note asks you to place the view once Herdr starts, run that `rig terminal open` yourself after they start it.
-  - **If it printed no command:** find `operator.agent` in `rig ps --nodes --rig kernel --json`, take its
-    `canonicalSessionName` (never a guessed name) and give
-    `env -u TMUX tmux attach-session -t '=<canonicalSessionName>'` for the operator's conversation.
+  - **If it printed no command:** find `operator.agent` in
+    `rig ps --nodes --rig kernel --json --fields logicalId,canonicalSessionName,tmuxAttachCommand` and give
+    `env -u TMUX` followed by its `tmuxAttachCommand`, exactly as listed (never a guessed name), for the operator's
+    conversation. That command names the daemon's tmux server when it isn't the default one.
 
   For any other failure, the table under "What can interrupt installation and the OpenRig view" in
   `rig context get reference/getting-started.md#open-the-kernel-conversations` says why and what to do next.
@@ -80,7 +81,8 @@ guidance in `AGENTS.md` or `CLAUDE.md` plus the team's skills and plugins. Say s
   `rig send <canonicalSessionName> 'This is the agent that installed OpenRig. The person will answer in your pane. Goal: <goal>. Project folder: <absolute path>. Branch: <branch>.'`
   Or the person types the goal and folder in the operator's pane. If they give you a goal later, forward it the same
   way. The operator helps them pick a team that fits their logins, starts it on their yes and gives the goal to the
-  team's lead. Show them where the operator answers, and don't build the project yourself.
+  team's lead. Before that yes, it says what launching into their folder changes for their own agent there; relay
+  that with the question. Show them where the operator answers, and don't build the project yourself.
 - **Relay the operator's questions:** the operator asks in its own pane, and the person may not be looking there.
   After each step you hand it, read its screen with `rig capture <canonicalSessionName>`. When it asks the person
   something (start this team? which folder? which option?), ask them here in the operator's words and send their

package/daemon/context-packs/help/manifest.yaml

@@ -1,6 +1,6 @@
 # Agent help: the single troubleshooting and escalation guide (docs/reference/help.md).
 name: help
-version: "0.6.8"
+version: "0.6.10"
 taxonomy: world
 purpose: "What an agent does when its user says OpenRig isn't working: diagnose, fix within permissions, verify, and escalate to OpenRig support."
 files:

package/daemon/context-packs/onboarding-width/manifest.yaml

@@ -1,6 +1,6 @@
 # Public capability and source-map width for the default onboarding walk.
 name: onboarding-width
-version: "0.6.8"
+version: "0.6.10"
 taxonomy: world
 purpose: "The public capability map and source map referenced by the default onboarding walk."
 files: