@openrig/cli 0.6.8 → 0.6.9

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/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.8"
+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.8"
+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.8`). 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
@@ -340,8 +348,8 @@ 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. Add `--plan` to preview it first, locally or with `--host`; a plan is never sent to a
+- **`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;
@@ -519,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
@@ -679,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

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.8"
+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: