@openrig/cli 0.5.6 → 0.5.8

package/daemon/assets/plugins/openrig-core/README.md

@@ -4,7 +4,7 @@ Canonical OpenRig skills and hooks for cross-runtime agent topology coordination
 
 ## What this plugin ships
 
-**Skills (16):** canonical OpenRig operating knowledge, including the public `refocusing` skill and
+**Skills (17):** canonical OpenRig operating knowledge, including the public `refocusing` skill and
 its path-only topology/work trace.
 
 **Hooks:** activity tracking, compaction continuity, and the default-on refocus channel. Refocus is

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

@@ -91,6 +91,28 @@ function readConfiguredContent(home) {
   };
 }
 
+// A live seat carries no OPENRIG_REFOCUS_WORK_NODE, so the trace used to report an
+// unresolved work node while the daemon could already name the seat's typed baton. Ask it.
+// The explicit variable always wins and short-circuits the call; any failure here returns
+// null and leaves the pre-existing gap line intact, because refusing to answer is correct
+// and guessing a work node would silently re-point the whole trace.
+function deriveWorkStart() {
+  if (process.env.OPENRIG_REFOCUS_WORK_NODE) return process.env.OPENRIG_REFOCUS_WORK_NODE;
+  const result = spawnSync("rig", ["queue", "whoami", "--json"], {
+    encoding: "utf8",
+    env: process.env,
+    timeout: 2_000,
+    maxBuffer: 16 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0 || !result.stdout || !result.stdout.trim()) return null;
+  try {
+    const workNodePath = JSON.parse(result.stdout)?.currentWork?.workNodePath;
+    return typeof workNodePath === "string" && workNodePath ? workNodePath : null;
+  } catch {
+    return null;
+  }
+}
+
 function renderTrace() {
   const script = path.resolve(__dirname, "../../skills/refocusing/scripts/trace-to-root.py");
   const args = [
@@ -101,8 +123,9 @@ function renderTrace() {
   if (process.env.OPENRIG_REFOCUS_TOPOLOGY_NODE) {
     args.push("--topology-start", process.env.OPENRIG_REFOCUS_TOPOLOGY_NODE);
   }
-  if (process.env.OPENRIG_REFOCUS_WORK_NODE) {
-    args.push("--work-start", process.env.OPENRIG_REFOCUS_WORK_NODE);
+  const workStart = deriveWorkStart();
+  if (workStart) {
+    args.push("--work-start", workStart);
   }
   const result = spawnSync(process.env.PYTHON || "python3", args, {
     encoding: "utf8",

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

@@ -6,7 +6,12 @@ import { spawnSync } from "node:child_process";
 
 const skillRoot = path.resolve(new URL("..", import.meta.url).pathname);
 const restoreScript = path.join(skillRoot, "scripts", "restore-from-jsonl.mjs");
-const outRoot = "/tmp/claude-compaction-restore";
+// P6(C) injectable output-root: the packet base defaults to the shared
+// /tmp/claude-compaction-restore (production), but becomes per-run isolated when the
+// hermetic env-var OPENRIG_COMPACTION_OUT_ROOT is set — so concurrent writers with the
+// same injected clock + sessionId no longer collide on the same `${sessionId}-${stamp}`
+// dir. Mirrors the injectable-clock seam (OPENRIG_TEST_CLOCK_NOW). Empty/absent = /tmp.
+const outRoot = process.env.OPENRIG_COMPACTION_OUT_ROOT || "/tmp/claude-compaction-restore";
 const defaultRestoreInstruction =
   "Read the claude-compaction-restore skill and follow its \"If You Just Compacted\" protocol.";
 
@@ -24,6 +29,14 @@ function getOpenRigHome() {
   return process.env.OPENRIG_HOME || process.env.RIGGED_HOME || path.join(os.homedir(), ".openrig");
 }
 
+// A3-R3 injectable clock (slice 51-01): marker.createdAt defaults to real wall-clock,
+// but becomes deterministic when the shared hermetic env-var OPENRIG_TEST_CLOCK_NOW is
+// set (an ISO instant). Empty/absent = production real-time.
+function nowIso() {
+  const injected = process.env.OPENRIG_TEST_CLOCK_NOW;
+  return typeof injected === "string" && injected.trim().length > 0 ? injected : new Date().toISOString();
+}
+
 function expandInstructionPath(filePath) {
   if (filePath.startsWith("~/")) return path.join(os.homedir(), filePath.slice(2));
   if (filePath.startsWith("${OPENRIG_HOME}/")) {
@@ -41,6 +54,50 @@ function readInstructionFile(filePath) {
   return fs.readFileSync(expanded, "utf8");
 }
 
+// OPR.0.4.1.09 / R5 marker-lifecycle (foreign-content-in-marker face): the hook
+// path must apply the SAME seat-check the daemon enforcer's resolvePostCompactExtra
+// applies (rev1-r2 dcd95bd9), or a FOREIGN seat's global messageFilePath leaks into
+// THIS seat's marker. Parse a WELL-FORMED leading `---` frontmatter for a declared
+// seat (target_seat / seat / session); body text is never scanned; a broken/absent
+// fence is GENERIC (valid for any seat). Byte-mirrors the enforcer regexes.
+function declaredSeatOf(content) {
+  const fm = /^\s*---\s*\n([\s\S]*?)\n---/.exec(content);
+  if (!fm) return null;
+  const m = /^[ \t]*(?:target[_-]?seat|seat|session(?:[_-]?name)?)[ \t]*:[ \t]*["']?([^"'\n#]+?)["']?[ \t]*$/im.exec(fm[1]);
+  return m ? m[1].trim() : null;
+}
+
+function sanitizeSeat(value) {
+  return value.replace(/[^a-zA-Z0-9_.@-]/g, "_");
+}
+
+// Resolve the post-compaction extra FOR THIS SEAT (mirror of the enforcer): (1) prefer
+// a per-seat compaction/post-compact-extra/<seat>.md — no cross-seat contamination
+// possible; (2) fall back to the global ONLY when it does not declare a DIFFERENT seat
+// (a wrong-seat global is REFUSED). Generic/undeclared/configured-but-absent stay
+// allowed. Returns the path to read, or null when nothing valid for this seat.
+function resolveSeatSafeExtraPath(globalFilePathRaw) {
+  const rawSeat = process.env.OPENRIG_SESSION_NAME || process.env.RIGGED_SESSION_NAME || "";
+  const seatKey = rawSeat ? sanitizeSeat(rawSeat) : "";
+  if (seatKey) {
+    const perSeatPath = path.join(getOpenRigHome(), "compaction", "post-compact-extra", `${seatKey}.md`);
+    if (fs.existsSync(perSeatPath)) {
+      const declared = declaredSeatOf(fs.readFileSync(perSeatPath, "utf8"));
+      if (declared && sanitizeSeat(declared) !== seatKey) return null; // wrong-seat per-seat file
+      return perSeatPath;
+    }
+  }
+  const trimmed = (globalFilePathRaw || "").trim();
+  if (!trimmed) return null;
+  const expanded = expandInstructionPath(trimmed);
+  // configured-but-absent: keep the path (an absent file cannot be a wrong-seat leak;
+  // readInstructionFile returns "" so nothing is appended).
+  if (!fs.existsSync(expanded)) return trimmed;
+  const declared = declaredSeatOf(fs.readFileSync(expanded, "utf8"));
+  if (declared && sanitizeSeat(declared) !== seatKey) return null; // foreign-seat global REFUSED
+  return trimmed;
+}
+
 function sessionKey(input) {
   const raw = [
     process.env.OPENRIG_SESSION_NAME,
@@ -58,12 +115,28 @@ function pendingMarkerPath(input) {
   return path.join(getOpenRigHome(), "compaction", "restore-pending", `${sessionKey(input)}.json`);
 }
 
+// R5 absent-when-needed: drop a lightweight EXPECTED sentinel FIRST (before the packet is
+// generated + the marker is written), carrying the SAME identity binding the marker gets.
+// Its presence-without-a-marker is what lets the bridge be LOUD about a missing packet
+// (hook died partway / write failed); policy off = no hook = no sentinel = silent.
+function writeExpectedSentinel(input) {
+  const p = path.join(getOpenRigHome(), "compaction", "restore-pending", `${sessionKey(input)}.expected.json`);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, `${JSON.stringify({
+    version: 1,
+    sessionName: process.env.OPENRIG_SESSION_NAME || process.env.RIGGED_SESSION_NAME || null,
+    sessionId: input.session_id || input.sessionId || null,
+    transcriptPath: input.transcript_path || null,
+    createdAt: nowIso(),
+  }, null, 2)}\n`, "utf8");
+}
+
 function writePendingRestoreMarker(input, parsed, restoreInstruction, customMessage) {
   const markerPath = pendingMarkerPath(input);
   fs.mkdirSync(path.dirname(markerPath), { recursive: true });
   const payload = {
     version: 1,
-    createdAt: new Date().toISOString(),
+    createdAt: nowIso(),
     sessionName: process.env.OPENRIG_SESSION_NAME || process.env.RIGGED_SESSION_NAME || null,
     sessionId: input.session_id || input.sessionId || null,
     transcriptPath: input.transcript_path || null,
@@ -118,13 +191,18 @@ function readClaudeCompactionMessage() {
     parts.push(`Inline restore instruction:\n${inline}`);
   }
   if (filePath && filePath.length > 0) {
-    try {
-      const fileText = readInstructionFile(filePath);
-      if (fileText) {
-        parts.push(`Additional restore instruction file (${filePath}):\n${fileText}`);
+    // R5 seat-check: resolve to the per-seat extra or a seat-safe global; a
+    // foreign-seat global resolves to null and is never injected into this marker.
+    const resolved = resolveSeatSafeExtraPath(filePath);
+    if (resolved) {
+      try {
+        const fileText = readInstructionFile(resolved);
+        if (fileText) {
+          parts.push(`Additional restore instruction file (${resolved}):\n${fileText}`);
+        }
+      } catch {
+        // Keep any inline instruction; unreadable extra files degrade quietly.
       }
-    } catch {
-      // Keep any inline instruction; unreadable extra files degrade quietly.
     }
   }
   if (parts.length > 0) return parts.join("\n\n");
@@ -140,7 +218,16 @@ function buildSystemMessage(restoreInstruction, customMessage) {
 }
 
 try {
+  // Slice 51-01 RIDER (leak-visibility, review-r1 escalation): OPENRIG_TEST_CLOCK_NOW is
+  // read by nowIso() to make createdAt deterministic in tests — but a LEAKED var in a
+  // real seat would silently FREEZE production createdAt. Announce loudly on stderr when
+  // active so any leak is visible in seat logs; absence stays silent (production path).
+  // MUST stay byte-identical to STUB_CLOCK_ANNOUNCEMENT in stub-runner.ts.
+  if (typeof process.env.OPENRIG_TEST_CLOCK_NOW === "string" && process.env.OPENRIG_TEST_CLOCK_NOW.trim().length > 0) {
+    process.stderr.write("OPENRIG_TEST_CLOCK_NOW active — timestamps are injected\n");
+  }
   const input = readHookInput();
+  writeExpectedSentinel(input); // R5: sentinel FIRST, before the packet + marker (catches hook-died-partway)
   const args = [restoreScript, "--out", outRoot, "--json"];
   if (input.cwd) args.push("--cwd", input.cwd);
   if (input.transcript_path && input.transcript_path.endsWith(".jsonl") && fs.existsSync(input.transcript_path)) {

package/daemon/assets/plugins/openrig-core/skills/claude-compaction-restore/scripts/restore-from-jsonl.mjs

@@ -423,8 +423,16 @@ function restoreInstructions(summary, outputPaths) {
   return lines.join("\n");
 }
 
+// A3-R3 injectable clock (slice 51-01): the packet output-dir timestamped path
+// defaults to real wall-clock, but becomes deterministic when the shared hermetic
+// env-var OPENRIG_TEST_CLOCK_NOW is set (an ISO instant). Empty/absent = production.
+function nowIso() {
+  const injected = process.env.OPENRIG_TEST_CLOCK_NOW;
+  return typeof injected === "string" && injected.trim().length > 0 ? injected : new Date().toISOString();
+}
+
 function writeOutputs(summary, outRoot) {
-  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const stamp = nowIso().replace(/[:.]/g, "-");
   const base = path.join(outRoot, `${summary.sessionId ?? "unknown-session"}-${stamp}`);
   fs.mkdirSync(base, { recursive: true });
 

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

@@ -0,0 +1,34 @@
+---
+name: loading-addressable-markdown
+description: Use when a mission, slice, dashboard, or task references Markdown as path#h2-slug or path#h2-slug/h3-slug outside the OpenRig context-pack library.
+---
+
+# Loading Addressable Markdown
+
+## Overview
+
+Load exactly one addressed Markdown section from any filesystem tree. The resolver mirrors OpenRig's shipped H2/H3 grammar without requiring the file to live in the context library.
+
+## Use
+
+Run the bundled script. Relative file references resolve from `--root`; without it they resolve from the current directory.
+
+```bash
+node ~/.agents/skills/loading-addressable-markdown/scripts/resolve-markdown.mjs \
+  --root /path/to/mission \
+  'slices/09-source-cleanup/SPEC.md#proposal'
+```
+
+The accepted forms are:
+
+- `file.md` — whole file
+- `file.md#h2-slug` — full H2 span, including child sections
+- `file.md#h2-slug/h3-slug` — full H3 span
+
+Slugs are lowercase; Markdown emphasis/code markers are removed; each other non-alphanumeric run becomes `-`. Duplicate or missing paths fail loudly. Headings inside fenced code blocks are ignored.
+
+## Common mistakes
+
+- Do not use `rig context get` for an arbitrary filesystem path; that command resolves context-library refs.
+- Do not hand-slice headings with `sed` or line numbers; the bundled resolver owns span and fence behavior.
+- Quote addresses in shell commands.

package/daemon/assets/plugins/openrig-core/skills/loading-addressable-markdown/scripts/resolve-markdown.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+import { readFile } from "node:fs/promises";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const MIN_LEVEL = 2;
+const MAX_LEVEL = 3;
+
+export class AddressResolutionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AddressResolutionError";
+  }
+}
+
+export function slugifyHeader(title) {
+  return title
+    .toLowerCase()
+    .replace(/[`*_~]/g, "")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+export function parseAddress(address) {
+  const hashCount = (address.match(/#/g) ?? []).length;
+  if (hashCount > 1) {
+    throw new AddressResolutionError(`address '${address}' must contain at most one '#' separator`);
+  }
+
+  const [ref, headerPart] = hashCount === 1 ? address.split("#") : [address, undefined];
+  if (!ref) throw new AddressResolutionError(`address '${address}' has no file before '#'`);
+  if (headerPart === undefined) return { ref, headerPath: [] };
+
+  const headerPath = headerPart.split("/");
+  if (headerPath.some((segment) => segment.length === 0)) {
+    throw new AddressResolutionError(`address '${address}' has an empty header segment`);
+  }
+  if (headerPath.length > MAX_LEVEL - MIN_LEVEL + 1) {
+    throw new AddressResolutionError(`address '${address}' is too deep; addresses target H2 and H3 only`);
+  }
+  return { ref, headerPath };
+}
+
+function scanHeaders(lines) {
+  const hits = [];
+  let fence = null;
+
+  for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+    const line = lines[lineNumber];
+    const fenceMatch = line.match(/^\s{0,3}(`{3,}|~{3,})/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1][0];
+      const length = fenceMatch[1].length;
+      if (!fence) fence = { marker, length };
+      else if (fence.marker === marker && length >= fence.length) fence = null;
+      continue;
+    }
+    if (fence) continue;
+
+    const heading = line.match(/^(#{1,6})\s+(.*\S)\s*$/);
+    if (heading) hits.push({ level: heading[1].length, title: heading[2], line: lineNumber });
+  }
+  return hits;
+}
+
+export function parseMarkdownSections(text) {
+  const lines = text.split("\n");
+  const headers = scanHeaders(lines);
+  const sections = [];
+  let currentH2 = null;
+
+  for (let index = 0; index < headers.length; index++) {
+    const heading = headers[index];
+    if (heading.level < MIN_LEVEL || heading.level > MAX_LEVEL) {
+      if (heading.level < MIN_LEVEL) currentH2 = null;
+      continue;
+    }
+
+    const slug = slugifyHeader(heading.title);
+    if (heading.level === 2) currentH2 = slug;
+    const headerPath = heading.level === 2
+      ? [slug]
+      : currentH2 !== null
+        ? [currentH2, slug]
+        : [slug];
+    const fullEnd = headers.slice(index + 1).find((next) => next.level <= heading.level)?.line ?? lines.length;
+    const ownEnd = headers[index + 1]?.line ?? lines.length;
+
+    sections.push({
+      level: heading.level,
+      title: heading.title,
+      headerPath,
+      headerLine: heading.line,
+      text: lines.slice(heading.line, fullEnd).join("\n"),
+      ownText: lines.slice(heading.line, ownEnd).join("\n"),
+    });
+  }
+  return sections;
+}
+
+export function resolveAddress(text, headerPath) {
+  if (headerPath.length === 0) {
+    throw new AddressResolutionError("a bare file resolves without section lookup");
+  }
+
+  const sections = parseMarkdownSections(text);
+  const wanted = headerPath.join("/");
+  const hits = sections.filter((section) => section.headerPath.join("/") === wanted);
+  if (hits.length > 1) {
+    throw new AddressResolutionError(
+      `address '#${wanted}' is AMBIGUOUS: ${hits.length} sections match at lines ${hits.map((hit) => hit.headerLine + 1).join(", ")}`,
+    );
+  }
+  if (hits.length === 1) return hits[0];
+
+  const parentPath = headerPath.slice(0, -1).join("/");
+  const candidates = sections
+    .filter((section) => section.headerPath.slice(0, -1).join("/") === parentPath)
+    .map((section) => section.headerPath.join("/"));
+  throw new AddressResolutionError(
+    `address '#${wanted}' matches no header. ` +
+      (candidates.length > 0
+        ? `Addressable sections under '${parentPath || "(top)"}': ${candidates.join(", ")}.`
+        : `Addressable sections: ${sections.map((section) => section.headerPath.join("/")).join(", ") || "(none)"}.`),
+  );
+}
+
+function usage() {
+  return "Usage: resolve-markdown.mjs [--root DIR] FILE[#h2-slug[/h3-slug]]\n";
+}
+
+async function main(argv) {
+  let root = process.cwd();
+  const args = [...argv];
+
+  if (args[0] === "--help" || args[0] === "-h") {
+    process.stdout.write(usage());
+    return;
+  }
+  if (args[0] === "--root") {
+    if (!args[1]) throw new AddressResolutionError("--root needs a directory");
+    root = path.resolve(args[1]);
+    args.splice(0, 2);
+  }
+  if (args.length !== 1) throw new AddressResolutionError(usage().trim());
+
+  const { ref, headerPath } = parseAddress(args[0]);
+  const filePath = path.isAbsolute(ref) ? ref : path.resolve(root, ref);
+  const text = await readFile(filePath, "utf8");
+  process.stdout.write(headerPath.length === 0 ? text : resolveAddress(text, headerPath).text);
+}
+
+function isMainModule() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  main(process.argv.slice(2)).catch((error) => {
+    process.stderr.write(`${error.name ?? "Error"}: ${error.message}\n`);
+    process.exitCode = 1;
+  });
+}

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

@@ -54,6 +54,7 @@ These are auto-delivered to every rig; their name+description are already in you
 - **applying-a-permission-policy** — a rig or seat has a permission policy attached, or you're setting one up: translate it into the live harness configuration.
 - **claude-compaction-restore** — you just compacted (Claude). Restore from durable evidence before resuming real work.
 - **delegating-work** — deciding who should do a task: you, a spawned subagent, or a durable peer seat that already holds the context.
+- **loading-addressable-markdown** — a task names Markdown as `path#h2-slug` or `path#h2-slug/h3-slug` outside the context-pack library.
 - **session-compaction-and-restore** — preparing for, or recovering from, compaction (any runtime). The write- and read-side protocol.
 - **queue-handoff** — you're passing durable work to another seat or ending your turn. The queue is the work ledger, not chat.
 - **refocusing** — a long-running seat may have lost the product outcome, crossed a major boundary, or compacted and needs a fresh path-based trace.
@@ -105,10 +106,6 @@ General engineering skills OpenRig ships as vendored copies. Open when the task
 - **test-driven-development** — implementing a feature or bugfix: write the failing test first.
 - **verification-before-completion** — about to claim done / passing / fixed: run the check and read the output first.
 - **systematic-debugging** — debugging: find the root cause before the fix.
-- **writing-plans** — writing an implementation plan.
-- **executing-plans** — working through a written plan.
-- **brainstorming** — divergent ideation before converging.
-- **using-superpowers** — discovering and using the vendored "superpowers" skill set.
 - **agent-browser** — driving a browser (screenshot / screencast) from an agent.
 - **frontend-design** — designing frontend / UI.
 - **dogfood** — web-QA / dogfooding a shipped UI.

package/daemon/assets/plugins/openrig-core/skills/retiring-and-inheriting-a-seat/SKILL.md

@@ -107,9 +107,9 @@ tenure:
 - **tombstone** — one line: what this tenure did, written by the retiring agent itself
 
 **Why it works (zero search infrastructure):** any timestamped record — a git commit, a
-qitem, a MISSION_NOTES line, a stream item — joins to the seat's ledger by interval match →
-generation + session token → wake that tenure. One row per handover, append-only. (Per-seat
-MISSION_NOTES continuation entries already *are* this record — the ledger formalizes them.)
+qitem, a NOTES.md line, a stream item — joins to the seat's ledger by interval match →
+generation + session token → wake that tenure. One row per handover, append-only. The
+ledger is the tenure record; work-tree notes remain lived context, not identity state.
 
 **Crash-ended tenures** get their row appended **post-hoc** by the crash-cart / restore path,
 flagged **honest-approximate** (the boot-captured session id is what makes this recoverable).

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

@@ -1,15 +1,10 @@
 ---
 name: software-for-agents
 description: |
-  Load this FIRST, before you assume how anything here works — especially before building, modifying, or
-  "fixing a bug" in an OpenRig or studio-box system, or when something behaves unexpectedly and you're
-  about to treat it as a code bug. You are almost certainly NOT operating in traditional software. This
-  is a self-improving MARKDOWN CONTROL PLANE: the substrate is markdown + YAML + JSON + folder structure
-  (skills, instructions, bootstrap files, schemas, conventions), and most "bugs" are coherence gaps in
-  that layer, not broken functions. Read this to form the correct mental model so your fixes land at the
-  precise spot that stops the footgun for every future rig — not just patch a symptom. It also covers why STUDIO APPS skip the mockup phase — for an agent-built app the build is as fast as the mockup, so the PRD is the fleshed intent (velocity as method, not a quality waiver). NOTE: the
-  bug-tolerance in this model is SCOPED to agent-managed software; the OpenRig core and rigs.to stay
-  rock-solid — see the scope block up top before you apply anything here.
+  Use when building, modifying, or diagnosing an OpenRig or studio-box system; when surprising behavior
+  looks like a code bug but may come from Markdown, YAML, JSON, bootstrap files, schemas, skills, or
+  conventions; or when deciding whether an agent-built studio app needs a separate mockup phase. NOT for
+  treating defects in OpenRig core or rigs.to as tolerable control-plane drift.
 metadata:
   openrig:
     stage: factory-approved

package/daemon/assets/vm-preview-fixtures/workflows/sample-basic-loop.yaml

@@ -18,16 +18,16 @@ workflow:
       skill_refs: [openrig-user, backlog-capture]
       preferred_targets: [intake-lead@conveyor]
     planner:
-      skill_refs: [openrig-user, writing-plans]
+      skill_refs: [openrig-user, verification-before-completion]
       preferred_targets: [plan-planner@conveyor]
     builder:
-      skill_refs: [openrig-user, executing-plans]
+      skill_refs: [openrig-user]
       preferred_targets: [build-builder@conveyor]
     reviewer:
       skill_refs: [openrig-user, review-team]
       preferred_targets: [review-reviewer@conveyor]
     closer:
-      skill_refs: [openrig-user, verification-before-completion]
+      skill_refs: [openrig-user]
       preferred_targets: [intake-lead@conveyor]
   steps:
     - id: intake

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.5.6"
+version: "0.5.8"
 # OPR.0.5.6.10 — affordances knowledge (what this system can do) is world
 # content under the coining-session definitions.
 taxonomy: world