@openrig/cli 0.6.7 → 0.6.9

package/README.md

@@ -22,11 +22,11 @@ Not setting this up today? Get the next walkthrough and occasional OpenRig updat
 
 Requires Node.js 22 or 24 and tmux, on macOS or Linux. On Linux, the distribution's own Node.js can be older (Ubuntu 24.04's is 18); install a supported version with [nvm](https://github.com/nvm-sh/nvm) (`nvm install 22`) or NodeSource. On a Mac with Apple silicon, use Node.js 22 ([compatibility history](docs/releases/v0.5.15.md#known-compatibility-limitation)). On Windows, use WSL2, the Windows route OpenRig supports; native Windows isn't supported. OpenRig's automated tests don't run on WSL2 yet; see [one user's working setup](docs/reference/getting-started.md#wsl2-a-reported-working-setup). Launching a rig writes provider hooks and workspace trust settings. Before running the commands below, read [what OpenRig changes on your machine](#what-openrig-changes-on-your-machine) and back up the relevant files.
 
-**One command.** This runs OpenRig's install script from the `v0.6.7` release. It checks Node.js and npm, installs the latest published `@openrig/cli` with `npm install -g`, runs the Node.js and SQLite check, then runs `rig setup --dry-run` and `rig setup`. The first line prints that plan and changes nothing:
+**One command.** This runs OpenRig's install script from the `v0.6.8` release. It checks Node.js and npm, installs the latest published `@openrig/cli` with `npm install -g`, runs the Node.js and SQLite check, then runs `rig setup --dry-run` and `rig setup`. The first line prints that plan and changes nothing:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.7/scripts/install.sh | sh -s -- --dry-run
-curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.7/scripts/install.sh | sh
+curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.8/scripts/install.sh | sh -s -- --dry-run
+curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.8/scripts/install.sh | sh
 ```
 
 If a provider isn't signed in yet, the last step reports `FAILED [4/4]`, and `rig setup` lists the sign-in under "Some steps need attention". If the only remaining failures are provider sign-ins, the install steps finished; sign in to each selected provider as below and continue.
@@ -107,7 +107,9 @@ recommends one of three, and fits it to the providers you have.
 
 As shipped, `starter` uses both Claude Code and Codex. With only one of them, ask
 the kernel operator to adapt it: it writes a copy of the team for your providers
-under the same name. `first-project` is starter's old name and still starts it,
+under the same name. [The naming guide](docs/reference/topology-naming.md) explains
+how their pods and roles grow and how to name your own team. `first-project` is
+starter's old name and still starts it,
 unless you already have a rig named `first-project` or `starter`: then it refuses
 and names the `rig up <name> --existing` command that brings that rig back.
 Show the selected runtime, configured model and command before launch; confirm the

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

@@ -92,16 +92,30 @@ the human (a pending human decision, or a row parked on the human), since a
 reply in that thread would answer the decision. In every such case the
 `--verify` result says `threaded: false` with the reason.
 
+To answer a reply the human typed inside one of your threads, `--reply-to` the
+row their reply landed as. The update posts in that thread unless one of the
+cases above applies, and `--verify` reports it the same way. A message the
+human started at the top level of the channel has no thread yet, so the answer
+posts as a new message.
+
 A **decision** with a few clear choices can carry `--human-questions-file <path>`:
 a JSON array of 1–4 questions, each
 `{"id", "question", "options": [{"id", "label", "recommended"?}]}` with 2–4
 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/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/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.7"
+version: "0.6.9"
 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.7"
+version: "0.6.9"
 taxonomy: world
 purpose: "The public capability map and source map referenced by the default onboarding walk."
 files:

package/daemon/context-packs/onboarding-width/public-what-you-can-do.md

@@ -11,7 +11,7 @@ not know exists.** So the point of what follows is not skill. It is recognition:
 lands, something rhymes, and you go check instead of building.
 
 Eighty-seven top-level verbs ship (capability canon refreshed through
-`capability-delta-v0.6.7`). This marker describes the pack's teaching, not publication or live
+`capability-delta-v0.6.9`). This marker describes the pack's teaching, not publication or live
 adoption. Read this once for shape, and let it make you suspicious that a thing already exists.
 Model-divergence proclamations are live product (trust them; pins use canonical
 model IDs).
@@ -89,6 +89,9 @@ unseen — which makes messages the one delivery channel that never gets skipped
   confirm by effect, never relaunch on it. A send or wake to a seat whose latest hook is a
   question waiting for a person is refused with `target_needs_input`, even when its screen
   can't be read: read it with `rig capture` and get the question answered instead of retrying.
+  Over `--host` to an http-registered host, a send that may have reached the remote reads
+  `remote-outcome-unknown` ("Delivery UNCONFIRMED"): check the target with `rig capture <session>
+  --host <id>` before any resend. Only a host that was never reached reads as unreachable.
 - **`rig send --raw`** — send exact text or keystrokes without the From/To envelope;
   the interactive-prompt guard still applies. To deliberately drive an interactive prompt,
   **`--dangerously-interact --reason "<why>"`** is the explicit override and implies raw text.
@@ -110,7 +113,9 @@ unseen — which makes messages the one delivery channel that never gets skipped
   runtime tokens.
 - **`rig chatroom wait`** — block until a peer actually says something, instead of polling
   `capture` in a loop. Also `history`, `watch`, `topic` for a named thread that stays retrievable.
-  Its `--timeout` is in seconds and ignores a suffix, so `2m` means 2 seconds.
+  Its `--timeout` is in seconds and ignores a suffix, so `2m` means 2 seconds. Poll timeouts,
+  connection refusals, and reset or closed connections are retried until that deadline; other errors,
+  including an error answer from the daemon such as a removed rig, still end the wait.
 - **`rig stream emit` / `list` / `watch` / `archive`** — drop an observation somewhere the *next*
   agent will find it. Emitting costs nothing and does not interrupt anyone; the value appears when
   someone lists the stream before starting.
@@ -148,7 +153,10 @@ unseen — which makes messages the one delivery channel that never gets skipped
   readiness for the delivery decision and `queue create --verify` for its receipt; connector
   setup or verification is not an outbound human message. After a connection gap the daemon
   catches up on missed channel messages and marks them late; `rig slack status` shows the
-  connection and the catch-up state. **`rig slack channel-map list` / `set <match> <channel>` /
+  connection, the catch-up state, and the count of retained retry records for inbound messages,
+  reactions and click answers (kept across restarts, not a distinct-message count). A retained alert whose row closed before its retry isn't
+  posted; the row says why. Its `Delivery:` line says whether events are confirmed arriving;
+  "connected" alone is not delivery, and a connection that stops delivering is replaced. **`rig slack channel-map list` / `set <match> <channel>` /
   `remove <match>`** sends a rig's or seat's human-bound posts to its own channel (a seat match
   beats a rig match; the rest use the default channel). After a change, invite the app to each
   channel, run `rig slack verify`, and rewire the connector (`rig slack disable` then `enable`, or
@@ -157,7 +165,10 @@ unseen — which makes messages the one delivery channel that never gets skipped
   It needs the `reactions:read` scope and the `reaction_added` event (reinstall the app);
   `rig slack verify` warns when the scope is missing. A long ask is posted in numbered thread parts; one that
   still can't be posted comes back to the asking seat as a `slack-undeliverable` task. Replies
-  sent with “Also send to #channel” reach the seat like any other thread reply.
+  sent with “Also send to #channel” reach the seat like any other thread reply. A person's reply
+  inside a thread OpenRig opened is answered in that thread: answer with `rig queue create
+  --human-intent update --reply-to <the inbound reply's row>`; a top-level message is answered
+  top-level.
 
 ## Making work outlive you
 
@@ -223,7 +234,10 @@ relay is a reason to inspect the available routing, not to surrender judgment to
 
 - **`rig workflow specs`** — what can be started here, and which are shipped versus authored by
   this rig.
-- **`rig workflow validate`** — will this spec instantiate at all, before a run finds out for you.
+- **`rig workflow validate`** — will this spec instantiate at all, before a run finds out for you. A
+  step with no allowed exit that can finish it or route onward is reported as `step_cannot_finish`.
+  An allowed mapped exit is valid; in a dependency graph, `handoff` can finish a sink without a next
+  step.
 - **`rig workflow compile <mission>`** / **`instantiate-lifecycle`** — derive one executable graph
   from `project.yaml` → `mission.yaml` → `slice.yaml`, inspect it without writing, then start an
   eligible graph with an opaque replay key. Typed acceptance candidate, verdict, and evidence
@@ -314,7 +328,9 @@ fresh, since a web tool's cached copy can be older. The built-in shelf also hold
 `research`, `pm`, `secrets-manager` and `kernel`. Older names are gone: `adversarial-review`,
 `research-team` and `pm-team` became `code-review`, `research` and `pm` with no alias, and
 `first-project-claude`, `first-project-mixed`, `conveyor`, `demo`, `implementation-pair` and
-`product-team` were removed. Verify prerequisites (Node 22 or 24) and actual runtime readiness
+`product-team` were removed. When authoring a new team, read
+`docs/reference/topology-naming.md`: name the rig for its purpose, pods for domains,
+and members for their roles. Verify prerequisites (Node 22 or 24) and actual runtime readiness
 before work. The starter's Codex model `gpt-6-astra` needs a Codex newer than 0.145; when a Codex
 seat reports that, the operator offers to update Codex and restart that seat. Existing Herdr/cmux
 terminals can present the managed team through `rig terminal open`.
@@ -332,8 +348,9 @@ not have to tear one down to change it, and you rarely have to start from nothin
   human mode it first prints one line with each agent's last known activity, or “unknown”: a
   best-effort snapshot, not a record of what was interrupted. With `--host`, a remote teardown
   that reports errors exits 2.
-- **`rig launch <rig> [seat]`** — one seat is down; start just that one, without disturbing the
-  rest.
+- **`rig launch <rigId> [seat]`** — one seat is down; start just that one, without disturbing the
+  rest. It takes the rig ID from `rig ps --json`; a rig name gives `rig_not_found`. Add `--plan` to preview it first, locally or with `--host`; a plan is never sent to a
+  daemon older than 0.5.9, which would ignore it and launch.
 - **`rig seat launch <seat> --fresh --reason <why>`** — deliberately create a blank occupant for
   exactly one existing seat. It uses no resume, fork, rebuild, snapshot, or restore packet;
   siblings and durable work stay put, and unmanaged ambiguity refuses.
@@ -463,7 +480,8 @@ version, from checking the environment to a useful report to the OpenRig team.
   skill covers writing and reading the map; `claude-compact-in-place` no longer ships. After a
   managed compaction, refocus waits for the restore request, which names the `refocusing` skill
   (the daemon installs it globally); three failed refocus attempts in a row for one occupant post
-  one issue to the stream.
+  one issue to the stream. The turn boundary, restore request and read-depth audit reach a seat
+  that stays quiet after `/compact`; they don't wait for its next turn.
 - **Know what compaction costs before you reach for it.** On some runtimes what comes back has
   enough context left to believe it knows everything and not enough to actually know anything — and
   **the compacted agent is the only one who knows it happened**, while every other seat keeps
@@ -509,7 +527,8 @@ scheme, and nothing downstream can see it.
 - **`rig scope slice progress` / `mission progress`** — record that a step moved, in a form the
   progress view can parse.
 - **`rig scope slice approve`** — freeze a decision — *this is the plan* or *this is delivered* —
-  so the freeze is recorded rather than asserted in chat.
+  so the freeze is recorded rather than asserted in chat. With `--workspace`, approve stamps the
+  tree you named, and refuses one with no `missions/` folder.
 - **`rig scope slice close` / `ship` / `move`** — retire it with the reason attached, move it into
   the release it belongs to preserving git history, or re-file it under a different mission.
 - **`rig scope slice stage` / `verified`** — how mature is this, and *when was it last checked and
@@ -550,8 +569,12 @@ scheme, and nothing downstream can see it.
   require `--project`. World packs named in `project.yaml`'s `install.worlds`
   are listed after the System World; read each with `rig context get <ref>`.
   `context profile` and `context work-install` both accept `--runtime claude-code` (alias
-  `claude`) or `codex`; explicit invalid values refuse before projection. This does not rename
-  every other command's runtime vocabulary.
+  `claude`) or `codex`; explicit invalid values refuse before projection. This does not rename every
+  other command's runtime vocabulary. A catalog skill with uncommitted content blocks only itself:
+  it is skipped and named (`catalog_skill_skipped`, or `selected_skill_skipped` with its selector).
+  With `--runtime`, work-install reports selected skips with exit 1. It inspects by default;
+  `--apply-skills` projects the remaining clean skills while keeping any previously projected copy
+  of the skipped skill. Commit or restore that skill's folder, then apply the projection again.
 - **`rig context show` / `sync` / `rm`** — what is inside a context pack before you prime a seat
   with it, and how to make the library catch up when you edit one. `sync` also finds a workspace
   pack created after the daemon started; a daemon restart is no longer needed.
@@ -665,7 +688,8 @@ reaching them is ordinary work rather than an escalation.
   request, then boundedly inspect its transport receipt. Posted means posted, not read;
   pending, failed, or indeterminate delivery leaves the row intact. Inspect the same row's
   transitions before retrying. `rig send` remains agent-terminal delivery only.
-  `--human-questions-file` adds clickable decision questions.
+  `--human-questions-file` adds clickable decision questions. A typed Slack reply to one is kept
+  in `humanAnswers`, placed under the first unanswered question; closing isn't approval.
 - **When project policy calls for human judgment or an update, load `messaging-the-human`.**
   Use `rig context get skills/core/messaging-the-human/SKILL.md` for a complete decision brief,
   related supplemental detail and explicit quiet-update intent. An FYI creates no approval
@@ -771,6 +795,9 @@ your circumstances is configuration, and the ones that are not, another agent ca
   it attaches to the existing kernel terminal; Ctrl-b then d detaches, and no missing
   seat or terminal is implicitly launched. Explain the failure and help with the
   chosen fallback. Plain `rig tui` remains a separate dashboard.
+  On an empty command line every typed command reaches the line whole and `j`/`k` move the
+  selection; the footer toggle is `F`, and a selected Scopes view's mini-requirements and
+  narrative keys are `M` and `N`.
   Open the instance row for one continuous cross-rig agent table with pod separators and material
   `RECENT` transitions; drill into a rig, mission, slice, or agent without losing the owning
   identity. Use the mission's workflow/packet view and Specs purpose/source to understand work.

package/daemon/context-packs/reference/getting-started.md

@@ -105,11 +105,11 @@ OpenRig view and the handoff to the operator as one procedure. From 0.6.7, OpenR
 script will do and changes nothing:
 
 ```sh
-curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.7/scripts/install.sh | sh -s -- --dry-run
+curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.8/scripts/install.sh | sh -s -- --dry-run
 ```
 
 The same command without `--dry-run`,
-`curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.7/scripts/install.sh | sh`, installs the
+`curl -fsSL https://raw.githubusercontent.com/mvschwarz/openrig/v0.6.8/scripts/install.sh | sh`, installs the
 latest published `@openrig/cli` with `npm install -g`,
 runs the Node.js and SQLite check, then `rig setup --dry-run` and `rig setup`. `rig setup` checks both Claude Code and
 Codex and may install a missing one, as described below. A failed step prints

package/daemon/context-packs/reference/instance-layout.md

@@ -79,6 +79,11 @@ Missing or malformed selections fail; absence is never inferred as disablement.
 `rig context work-install --json` reports the effective state, source, manifest,
 context selectors, and skills. With `--runtime`, its managed skill loadout then
 combines System World, topology, and Project World selectors with provenance.
+The catalog is a Git checkout. A skill folder with uncommitted or untracked content is
+skipped by itself and named. With `--runtime`, work-install reports selected skips with
+exit 1. It inspects by default; `--apply-skills` projects the remaining clean skills while
+keeping any previously projected copy of the skipped skill. An uncommitted change directly
+in the catalog root, such as `catalog.yaml`, still makes the whole catalog unavailable.
 
 For a pre-0.5.9 home, use the `openrig-upgrade` skill's
 `migrate-telemetry-state-0.5.9.mjs` helper as an Agent-Operated Migration. Its

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

@@ -1,7 +1,7 @@
 # Reference guides the help pack links to, loaded one file or section at a time by address
 # (rig context get reference/<file>#<section>). Each file is a symlink to docs/reference/.
 name: reference
-version: "0.6.7"
+version: "0.6.9"
 taxonomy: world
 purpose: "Version-matched reference guides the help guide links to. Load a single file or section by address; don't load the whole pack."
 files: