@openrig/cli 0.5.6 → 0.5.8

package/daemon/context-packs/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/context-packs/skills/mission-slice-sop/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: mission-slice-sop
+description: >-
+  Use when starting, building, handing off, restoring, or closing a mission or slice under the default lightweight SDLC.
+metadata:
+  openrig:
+    stage: shipped
+    sibling_skills:
+      - queue-handoff
+      - seat-continuity-and-handover
+      - claude-compaction-restore
+---
+
+# Mission/Slice SOP — Part A
+
+Use this skill to actually **do** mission/slice work: track on the canonical files, record what you proved, hand off through them, and survive compaction on them. **Do the work described here; do not merely explain the protocol.**
+
+**Full convention SSOT:** repo `docs/reference/sdlc-conventions.md`; installed `$OPENRIG_HOME/reference/sdlc-conventions.md`. This skill is the concise Part-A teaching surface and does not replace the full convention.
+
+## THIS IS THE LIGHT DEFAULT — read this before anything else
+
+**The default for any slice is the inner loop:** ground yourself → build → **test with your own eyes** → iterate → **ONE** full-breadth review at the end. That is the whole process. It is not a reduced form of a better process; it IS the process.
+
+**Part B is defined in the SSOT above and applies only when the human operator — or an orchestrator explicitly relaying that decision — assigns it to a named piece of work.** You may not select it yourself. If you believe something earns it, say so in one sentence and **continue on Part A** until told otherwise.
+
+## Proportionality — this SOP serves shipping; it is not the work itself
+
+The working product is the deliverable. This bookkeeping exists so the work survives handoff, compaction, and review — nothing more. **Match it to stakes.** The `rig scope audit` backstop is **advisory and fail-open**: it never blocks a build and is not a gate you clear before proceeding. If you're spending more time on the convention files or the audit than on the running product, stop and go build. Running the full apparatus on a small change is the letter-worship failure, not diligence.
+
+## The three role contracts
+
+- **Planning agent:** records what the slice is for and what "done" looks like, in the slice's own words; produces mockups for UI deliverables so the builder has something to look at (a UI slice with no mockup is an incomplete plan; non-UI slices have none — not a gate).
+- **Build agent:** builds it, and **looks at the mockups**. Verifies by running the thing.
+- **QA agent (owns the compare):** compares planned vs delivered per deliverable, records the verdict and the note. On mismatch: fix-and-re-review, or kick back with the reason — never escalate a raw mismatch to the human.
+
+These three are a division of labour, not a chain of gates. One agent may hold all three on a small slice.
+
+## The current file contract
+
+> These files are the **operating surface of the work** — you track on them, record on them, hand off through them, and survive compaction on them. Keep them current because that is what lets the work survive. But they **serve** the product; they are not the product. If you're polishing files while the actual thing isn't shipping, you've inverted it: go build, then update them.
+
+- **Slice:** `SPEC.md`, `PROGRESS.md`, `PROOF.md`, and `proof/`.
+- **Mission:** `SPEC.md` and `NOTES.md`.
+
+## Per-file rules — WHO / WHEN / HOW
+
+### SPEC.md
+- **WHO:** the planning owner authors it; builders and reviewers read it as the scope and intent source.
+- **WHEN:** at creation and whenever scope changes.
+- **HOW:** a slice carries `intent:` in frontmatter and opens with `## Intent`, `## Mini-requirements`, and `## Proof contract`. A mission carries its intent and mission-level specification in the same authored node file. Keep depth proportional to the work.
+
+### PROGRESS.md
+- **WHO:** the orchestrator owns `§1` (current state); every agent logs its own outcomes.
+- **WHEN:** on material delivery-state changes and at acceptance.
+- **HOW:** one line per outcome (checkbox), link down for detail; keep frontmatter `stage`/`verified` honest.
+
+### PROOF.md + proof/
+- **WHO:** the impl/QA pair that worked the slice.
+- **WHEN:** before you call a slice done.
+- **HOW:** say what you verified and how you verified it — **by effect**: you ran it and looked at the result. Put supporting media under `proof/`. State plainly what is proven and what is **not**; an honest "this half is untested" is worth more than a checkmark. If a drop verb is in play for this slice, prefer it over hand-placing files so the artifact carries its own provenance.
+
+### NOTES.md
+- **WHO:** any agent updates `§1` (top-of-mind); each seat owns and appends to its own `§A–§X`.
+- **WHEN:** on material mission-context changes; a compacting agent **files its state here BEFORE compaction and reads it on restore.**
+- **HOW:** accruing tribal knowledge — `§1` ≤ 5–15 lines (gates, open decisions, surprises); per-seat continuation entries (latest = truth; other seats read-only). Pointer-first; don't duplicate.
+
+## The lifecycle (4 legs)
+
+**SCAFFOLD** (`rig scope` creates the files from templates) → **POPULATE** (agents fill them as work happens) → **PROJECT** (the Living Notes UI reads them into INTENT → PLAN → DELIVERED) → **VERIFY** (`rig scope audit`, advisory). "Loose freeform write + deterministic verify."
+
+## Hot-potato (handoffs)
+
+End every turn by passing the ball — a `rig queue handoff` to the next agent. The handoff verb is **transactional**: it closes the source as handed-off and mints the successor owned by `--to`, so the baton cannot be dropped. A handoff terminates only at the orchestrator seat, which holds the context to judge whether a park is legitimate.
+
+**A plain `rig queue create` row is informational** — a durable message. It is not a baton and does not carry this obligation. Use `handoff` when you are passing real work; use `create` when you are informing.
+
+Never go idle holding a baton.
+
+## Verify (deterministic backstop)
+
+Run `rig scope audit` at slice-close. Every convention check is **advisory / fail-open** — it records and advises, never blocks a write. Fix what's real, skip what isn't, keep moving. **A clean audit score is not required to proceed.**
+
+## Reading terminal captures — KNOWN GOTCHA: ghost-text autocomplete is NOT real
+
+When you `rig capture` a pane, **greyed / ghost autocomplete suggestions are NOT real content** — they are autocomplete *previews*, not typed, staged, or committed input. **This has been faking agents out a lot**: reading a ghost suggestion in a peer's input box as "staged text they're about to send," then reasoning on a string that was never there.
+
+**Rule:** ignore ghost/autosuggest text entirely. Only *committed/rendered* pane output is real. When it matters, verify at source (git, the queue, the actual event) — never off a capture's ghost line.
+
+## Moment-of-truth checklist
+
+- **Starting a slice?** → do you know what it's for and what done looks like? mockups attached (UI slices)? **Are you on the light path?** (You are, unless the mission owner assigned the overlay.)
+- **Finishing a slice?** → does `PROOF.md` say what you actually verified, by effect, including what is NOT covered? `PROGRESS.md` updated? mission `NOTES.md` refreshed? handed off via `rig queue handoff`?
+- **Compacting?** → file your state in mission `NOTES.md`; on restore, read it plus the active slice's `SPEC.md`, `PROGRESS.md`, and `PROOF.md`.
+- **Starting on a mission?** → read mission `SPEC.md`, `NOTES.md`, and the conventions SSOT.

package/daemon/context-packs/skills/mission-slice-sop/manifest.yaml

@@ -0,0 +1,10 @@
+# GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
+# Package-time projection of a canonical skill; regenerated every build.
+name: "mission-slice-sop"
+version: "0.5.8"
+taxonomy: "skills"
+purpose: "Use when starting, building, handing off, restoring, or closing a mission or slice under the default lightweight SDLC."
+files:
+  - path: "SKILL.md"
+    role: "instruction"
+    summary: "Use when starting, building, handing off, restoring, or closing a mission or slice under the default lightweight SDLC."