create-agent-rig 0.10.1 → 1.0.1

package/templates/agent-os/universal/.claude/scripts/release-evidence.mjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+/**
+ * release-evidence.mjs — read-only, deterministic. Turns existing run-journal
+ * evidence (gate-blocker patterns, filed triage proposals) into a
+ * REPEATED_PAIN or GATHER_MORE_EVIDENCE verdict, for the `release-propose`
+ * skill to read (RP-203). It files nothing itself — see
+ * test/template/release-evidence.test.ts (absent in a generated rig).
+ *
+ *   node .claude/scripts/release-evidence.mjs --since <ISO> [--runs <dir>] [--json]
+ *
+ * Reads `<runs>/<run-id>/` the same way `revalidation-report.mjs` does — this
+ * script reuses that script's `readRuns` (default `--runs` also resolves
+ * through `queue/checkout.mjs`'s `mainCheckoutRoot`, the same main-checkout
+ * rule) and `run-journal.mjs`'s `readRun`. A run `readRun` refuses is counted
+ * under `runs.skipped`, with why, never dropped silently.
+ *
+ * Grouping keys: `gate-blocker|<gate>|<norm(rule)>` for each blocker on a
+ * `decisions.jsonl` record; `proposal|<data.id>` for each `events.jsonl`
+ * record with `kind === 'proposal'` and `data.ok === true`. A group is
+ * `repeated` only when its records come from at least `REPEATED_MIN_RUNS`
+ * distinct run directories — any number of records inside one run is one
+ * anecdote.
+ *
+ * Limits: grouping is lexical (exact gate plus a normalised blocker rule, or
+ * a proposal fingerprint) — merging rules that mean the same thing but read
+ * differently is inference this script does not attempt. Run independence is
+ * assumed, not proven: one PR can span more than one run directory, which
+ * this script has no way to detect and would then double-count as two.
+ */
+
+import { realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { mainCheckoutRoot } from './queue/checkout.mjs';
+import { readRuns } from './revalidation-report.mjs';
+
+export const REPEATED_MIN_RUNS = 2;
+
+const norm = (rule) => rule.trim().toLowerCase().replace(/\s+/g, ' ');
+
+/** The report over already-read runs — pure, so the grouping is testable alone. */
+export const evidenceOf = ({ runs, since }) => {
+  const sinceMs = Date.parse(since);
+  const read = [];
+  const skipped = [];
+  const groups = new Map();
+
+  const addRecord = (key, source, gate, label, run, at, pointer) => {
+    let group = groups.get(key);
+    if (!group) {
+      group = { key, source, gate, label, records: 0, runsSeen: new Set(), firstAt: at, lastAt: at, pointers: [] };
+      groups.set(key, group);
+    }
+    group.records += 1;
+    group.runsSeen.add(run);
+    if (Date.parse(at) < Date.parse(group.firstAt)) group.firstAt = at;
+    if (Date.parse(at) > Date.parse(group.lastAt)) group.lastAt = at;
+    group.pointers.push(pointer);
+  };
+
+  for (const entry of runs) {
+    if (entry.error) {
+      skipped.push({ run: entry.run, why: entry.error });
+      continue;
+    }
+    read.push(entry.run);
+
+    for (const record of entry.decisions ?? []) {
+      if (!(Date.parse(record.at) >= sinceMs)) continue;
+      for (const blockerItem of record.blockers ?? []) {
+        const rule = blockerItem?.rule;
+        if (typeof rule !== 'string' || rule.trim() === '') continue;
+        const gate = record.gate ?? 'unknown';
+        const label = norm(rule);
+        addRecord(`gate-blocker|${gate}|${label}`, 'gate-blocker', gate, label, entry.run, record.at, {
+          run: entry.run,
+          file: 'decisions.jsonl',
+          seq: record.seq,
+        });
+      }
+    }
+
+    for (const event of entry.events ?? []) {
+      if (event.kind !== 'proposal') continue;
+      if (event.data?.ok !== true) continue;
+      const id = event.data?.id;
+      if (id === undefined || id === null) continue;
+      if (!(Date.parse(event.at) >= sinceMs)) continue;
+      addRecord(`proposal|${id}`, 'proposal', null, String(id), entry.run, event.at, {
+        run: entry.run,
+        file: 'events.jsonl',
+        seq: event.seq,
+      });
+    }
+  }
+
+  const groupList = [...groups.values()].map((group) => ({
+    key: group.key,
+    source: group.source,
+    gate: group.gate,
+    label: group.label,
+    records: group.records,
+    runs: group.runsSeen.size,
+    repeated: group.runsSeen.size >= REPEATED_MIN_RUNS,
+    firstAt: group.firstAt,
+    lastAt: group.lastAt,
+    pointers: group.pointers,
+  }));
+
+  groupList.sort((a, b) => {
+    if (a.repeated !== b.repeated) return a.repeated ? -1 : 1;
+    if (a.runs !== b.runs) return b.runs - a.runs;
+    return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+  });
+
+  const verdict = groupList.some((group) => group.repeated) ? 'REPEATED_PAIN' : 'GATHER_MORE_EVIDENCE';
+  const why =
+    verdict === 'REPEATED_PAIN'
+      ? `at least one group recurred across ${REPEATED_MIN_RUNS}+ distinct run directories`
+      : 'no group recurred across distinct run directories since the window opened; an anecdote is not evidence';
+
+  return {
+    schemaVersion: 1,
+    since,
+    rule: {
+      repeatedMinRuns: REPEATED_MIN_RUNS,
+      unit: 'distinct run directory',
+      grouping: 'exact gate + normalised blocker rule; proposal fingerprint',
+    },
+    runs: { read: read.length, skipped },
+    groups: groupList,
+    verdict,
+    why,
+    limits: [
+      'grouping is lexical; merging similar rules is inference',
+      'run independence is assumed, not proven (one PR can span runs)',
+    ],
+  };
+};
+
+const parseArgs = (argv) => {
+  const args = { since: null, runs: null, json: false, bad: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--json') args.json = true;
+    else if (arg === '--since') args.since = argv[++i] ?? null;
+    else if (arg === '--runs') args.runs = argv[++i] ?? null;
+    else if (args.bad === null) args.bad = arg;
+  }
+  return args;
+};
+
+const invokedDirectly = () => {
+  if (!process.argv[1]) return false;
+  const real = (p) => {
+    try {
+      return realpathSync(p);
+    } catch {
+      return p;
+    }
+  };
+  return real(fileURLToPath(import.meta.url)) === real(process.argv[1]);
+};
+
+if (invokedDirectly()) {
+  const args = parseArgs(process.argv.slice(2));
+  const refuse = (message) => {
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+  };
+  if (args.bad !== null) refuse(`unrecognised argument: ${args.bad}`);
+  if (!args.since || Number.isNaN(Date.parse(args.since))) {
+    refuse(`--since needs an ISO date (got ${args.since ?? '(none)'}); a report with no window reports nothing honest.`);
+  }
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const runsDir = args.runs ?? join(mainCheckoutRoot(join(scriptsDir, '..', '..')), '.claude', 'runs');
+  let runs;
+  try {
+    runs = readRuns(runsDir);
+  } catch (error) {
+    refuse(error.message);
+  }
+  const evidence = evidenceOf({ runs, since: new Date(args.since).toISOString() });
+  // Always JSON: the one output shape `release-propose` reads. `--json` is
+  // accepted (every call site may pass it) but does not change the shape —
+  // there is no separate human-summary mode to opt out of.
+  process.stdout.write(`${JSON.stringify(evidence, null, 2)}\n`);
+}

package/templates/agent-os/universal/.claude/scripts/revalidation-report.mjs

@@ -124,8 +124,10 @@ export const readRuns = (runsDir) => {
   }
   return names.sort().map((run) => {
     try {
-      const { events } = readRun({ runDir: join(runsDir, run) });
-      return { run, events };
+      // `decisions` rides along unused here — added for release-evidence.mjs
+      // (RP-203), which reuses this same reader for its own grouping.
+      const { decisions, events } = readRun({ runDir: join(runsDir, run) });
+      return { run, decisions, events };
     } catch (error) {
       return { run, error: String(error?.message ?? error) };
     }

package/templates/agent-os/universal/.claude/scripts/unattended-flag.mjs

@@ -94,11 +94,147 @@ export const RULEBOOK_PREFIXES = Object.freeze([
   '.codex/',
   'AGENTS.md',
   'CLAUDE.md',
+  // the detection contract preflight and claim-records both read: it decides
+  // whether preflight STOPs and what the scope fingerprint watches, so an
+  // unattended run does not rewrite what its own revalidation checks against
+  // — outside its item's allow-list, like every other entry here and unlike
+  // `.claude/queue.board`, which `guard-rulebook` refuses even when the
+  // allow-list names it. The exact file, never `.rig/` — a SELECT still needs to
+  // write its own baseline under `.rig/claims/`, which stays unlisted here.
+  '.rig/revalidation.json',
 ]);
 
-/** Is this repo-relative path part of the rulebook? */
-export const isRulebookPath = (rel) =>
-  RULEBOOK_PREFIXES.some((prefix) => rel === prefix || rel.startsWith(prefix));
+// Case-folded once at module load, for the same comparison every caller shares
+// — never re-derived per call, and never used anywhere but inside
+// `isWidening` below (`canonicalRulebookPath` folds its own comparison from
+// `RULEBOOK_PREFIX_SEGMENTS` instead).
+const FOLDED_RULEBOOK_PREFIXES = RULEBOOK_PREFIXES.map((prefix) => prefix.toLowerCase());
+
+/**
+ * The canonical rulebook spelling of a repo-relative path, or `undefined`
+ * when it names no rulebook prefix at all. Case-insensitive on the PREFIX
+ * match only — NTFS and default APFS resolve a miscased spelling
+ * (`.Codex/config.toml`) to the same file as the canonical one, and this
+ * comparison is what a directory this checkout has never created yet (or
+ * any path on a case-sensitive filesystem) reaches, exactly as spelled by
+ * the caller — see the generator's `test/template/guard-rulebook.test.ts`
+ * (absent in a generated rig) › "guard-rulebook: blocks a miscased
+ * rulebook path even when the guarded directory does not exist on disk yet
+ * (RP-215)" › "blocks a Write to .Codex/config.toml when .codex/ is absent
+ * from the checkout".
+ *
+ * RP-215 round 2: the returned spelling replaces only the matched prefix
+ * characters with `RULEBOOK_PREFIXES`' own spelling — the remainder of the
+ * path (and any allow-list entry) keeps whatever case it was written in.
+ * This is the one place a path is re-cased; every comparison downstream
+ * (`isAllowed`, the `.claude/queue.board` carve-out in `guard-rulebook.mjs`)
+ * takes this canonical value and stays a literal, case-sensitive match —
+ * canonicalising the PATH, never folding the ALLOW-LIST, is what keeps a
+ * miscased allow entry (`.Claude/`, `.claude/Scripts/`) from ever matching
+ * anything, including the one prefix deliberately withheld as an allow root
+ * (`.claude/scripts/`, `isWidening`).
+ *
+ * RP-243: before the fold above, a trailing run of `.`/` ` is stripped from
+ * a path component — `.codex./config.toml` folds the same as
+ * `.codex/config.toml` — except a component made entirely of dots (`.`,
+ * `..`), left untouched so a traversal segment is never collapsed into an
+ * empty name. Only the PATH is normalised this way, never an allow-list
+ * entry — the same asymmetry as the case fold above.
+ *
+ * RP-243 round 2: only the components the matched prefix itself spans are
+ * normalised — bounded by the longest `RULEBOOK_PREFIXES` entry's own
+ * segment count, computed once below — so a component beyond that span
+ * keeps its literal spelling and the canonical path returns it raw. See the
+ * generator's `test/template/unattended-flag.test.ts` (absent in a
+ * generated rig) › "isRulebookPath: a trailing dot or space on a path
+ * component is judged the same as the component with it stripped (RP-243)".
+ */
+const stripTrailingDotsAndSpaces = (component) => {
+  if (/^\.+$/.test(component)) return component;
+  let end = component.length;
+  while (end > 0) {
+    const code = component.charCodeAt(end - 1);
+    if (code !== 46 /* '.' */ && code !== 32 /* ' ' */) break;
+    end -= 1;
+  }
+  return end === component.length ? component : component.slice(0, end);
+};
+
+/**
+ * `RULEBOOK_PREFIXES` split into segments once, at module load — a directory
+ * entry (`.claude/hooks/`) drops its trailing slash first, so both forms
+ * yield the segment names a path's own `/`-split components are compared
+ * against. `directory` records whether the entry itself ended in `/`: a
+ * directory entry needs an exact fold-match on every one of its segments
+ * plus something after them; a file entry (`CLAUDE.md`, `.rig/revalidation.json`)
+ * is matched with a `startsWith` on its last segment — see the generator's
+ * `test/template/unattended-flag.test.ts` (absent in a generated rig) ›
+ * "isRulebookPath: a path continuing past a matched FILE entry is still a rulebook path (round 3 regression)".
+ */
+const RULEBOOK_PREFIX_SEGMENTS = RULEBOOK_PREFIXES.map((prefix) => {
+  const directory = prefix.endsWith('/');
+  const segments = (directory ? prefix.slice(0, -1) : prefix).split('/');
+  const foldedSegments = segments.map((segment) => segment.toLowerCase());
+  return { prefix, directory, foldedSegments, length: segments.length };
+});
+
+// The most components any single entry's match can ever need to inspect —
+// never re-derived per call, and the only thing that bounds how many of a
+// path's own components `canonicalRulebookPath` normalises.
+const MAX_PREFIX_SEGMENTS = RULEBOOK_PREFIX_SEGMENTS.reduce(
+  (max, entry) => Math.max(max, entry.length),
+  0,
+);
+
+export const canonicalRulebookPath = (rel) => {
+  const components = rel.split('/');
+  const headCount = Math.min(components.length, MAX_PREFIX_SEGMENTS);
+  const normalisedHead = new Array(headCount);
+  const foldedHead = new Array(headCount);
+  for (let i = 0; i < headCount; i += 1) {
+    normalisedHead[i] = stripTrailingDotsAndSpaces(components[i]);
+    foldedHead[i] = normalisedHead[i].toLowerCase();
+  }
+  for (const entry of RULEBOOK_PREFIX_SEGMENTS) {
+    const { directory, foldedSegments, length: segmentCount, prefix } = entry;
+    if (components.length < segmentCount) continue;
+    let leadingMatches = true;
+    for (let i = 0; i < segmentCount - 1; i += 1) {
+      if (foldedHead[i] !== foldedSegments[i]) {
+        leadingMatches = false;
+        break;
+      }
+    }
+    if (!leadingMatches) continue;
+    const lastFolded = foldedHead[segmentCount - 1];
+    const lastSegment = foldedSegments[segmentCount - 1];
+    if (directory) {
+      if (lastFolded !== lastSegment) continue;
+      if (components.length === segmentCount) continue; // no trailing slash, nothing after
+      if (components.length === segmentCount + 1 && components[segmentCount] === '') {
+        return prefix; // the path itself ends with the literal trailing slash
+      }
+      return prefix + components.slice(segmentCount).join('/');
+    }
+    // File entry: the last spanned component is compared folded+normalised,
+    // same as every other component this function inspects; anything past
+    // it — the rest of that component, and every component after it — is
+    // returned exactly as written.
+    if (lastFolded === lastSegment) {
+      if (components.length === segmentCount) return prefix;
+      return `${prefix}/${components.slice(segmentCount).join('/')}`;
+    }
+    if (lastFolded.startsWith(lastSegment)) {
+      const extra = normalisedHead[segmentCount - 1].slice(lastSegment.length);
+      if (components.length === segmentCount) return prefix + extra;
+      return `${prefix}${extra}/${components.slice(segmentCount).join('/')}`;
+    }
+  }
+  return undefined;
+};
+
+/** Is this repo-relative path part of the rulebook? See `canonicalRulebookPath`. */
+export const isRulebookPath = (rel) => canonicalRulebookPath(rel) !== undefined;
 
 /**
  * Does this allow entry widen the rulebook? It is unsafe when it is an
@@ -108,14 +244,25 @@ export const isRulebookPath = (rel) =>
  * protected script paths sit under `.claude/scripts/`; a narrower path such as
  * `.claude/scripts/queue/` is an ordinary allow entry and does not widen it.
  * `src/` also does not widen it because the guard judges nothing there.
+ *
+ * RP-215 round 2: the entry is case-folded once before either comparison —
+ * the allow side now folds like the path side (`canonicalRulebookPath`) — so
+ * a miscased entry (`.Claude/`, `.claude/Scripts/`) is judged exactly like its
+ * canonical spelling instead of slipping through as ordinary, harmless text;
+ * see the generator's `test/template/unattended-flag.test.ts` (absent in a
+ * generated rig) › "isWidening: a miscased allow entry must be refused
+ * exactly like its canonical spelling (RP-215 round 2)".
  */
-export const isWidening = (entry) =>
-  typeof entry !== 'string' ||
-  entry === '' ||
-  entry === '.agents/' ||
-  entry === '.claude/scripts/' ||
-  entry === '.codex/' ||
-  RULEBOOK_PREFIXES.some((prefix) => prefix !== entry && prefix.startsWith(entry));
+export const isWidening = (entry) => {
+  if (typeof entry !== 'string' || entry === '') return true;
+  const folded = entry.toLowerCase();
+  return (
+    folded === '.agents/' ||
+    folded === '.claude/scripts/' ||
+    folded === '.codex/' ||
+    FOLDED_RULEBOOK_PREFIXES.some((prefix) => prefix !== folded && prefix.startsWith(folded))
+  );
+};
 
 /**
  * One spelling for one directory — the single canonicaliser this file compares

package/templates/agent-os/universal/.claude/skills/diagnose/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: diagnose
+description: Use when a check is red or a run crashed and the cause is not obvious, or when a claimed defect or historical finding needs confirming before work is planned on it.
+allowed-tools: Read, Grep, Glob, Bash, Task
+---
+
+# Diagnose before you fix
+
+Stop guessing. A red check or a crashed run is never a thing to retry until
+it goes green — that stop rule is already stated in
+`.claude/rules/autonomy.md` ("Flaky ≠ retry"); this skill does not restate
+it.
+
+## Hand it to `failure-diagnostician`
+
+Give the agent what it needs to reproduce, verbatim:
+
+- for a failure — the exact failure output, the command that produced it,
+  and the commit or branch where it failed;
+- for a claim — the claim's own text, and where it came from (a queue item,
+  a review comment, a prior finding).
+
+Dispatch `failure-diagnostician`. Its method is its own —
+`.claude/agents/failure-diagnostician.md` — not repeated here.
+
+## Check the answer, then act on the word
+
+Save its report to a file and run exactly:
+
+```sh
+node .claude/scripts/verdict.mjs check <report> failure-diagnostician
+```
+
+Exit 1 means it did not answer — that is no diagnosis, not a word to act on.
+
+| Verdict | Action |
+| --- | --- |
+| `ROOT_CAUSE` / `STILL_LIVE` | the failing test first, through `test-writer` — the Red step in `.claude/rules/workflow.md` |
+| `INCONCLUSIVE` / `INSUFFICIENT_EVIDENCE` | stop; escalate in the format `.claude/rules/autonomy.md` ("Escalation format") sets, carrying the verdict's blockers as what would decide the question |
+| `ALREADY_FIXED` / `OBSOLETE` | close the item, citing the verdict's `evidence` |
+
+This is a Core skill: it dispatches no opt-in-workflow-layer machinery, and
+routes on the word alone.

package/templates/agent-os/universal/.claude/skills/loop/SKILL.md

@@ -420,7 +420,11 @@ who was not reading the code at the time, and everything downstream — the fail
 test, the implementation, the reviewer comparing diff to item — inherits its
 claims rather than checking them. On `PREMISE FALSE` the item is escalated (§6),
 not repaired in place: a run that silently re-aims its own task has authored work
-for itself, which is the one thing this loop does not do (§8).
+for itself, which is the one thing this loop does not do (§8). A claim
+`check-premises` cannot settle by reading — a claimed defect or a historical
+finding that needs reproducing on the current default branch, not just re-reading — goes to
+`failure-diagnostician` in claim mode instead, never to an unnamed built-in
+subagent.
 
 🔴 **And again at the other end, before `pr-ship`: `check-premises` on the prose the
 task itself wrote** — the rulebook prose the diff touches (the skill defines that set,
@@ -703,7 +707,23 @@ Both then follow the same three steps:
    its clauses: what was *observed* (verbatim errors, not summaries), and the
    single question whose answer unblocks the work. So: what fails, what was tried, the
    current hypothesis, and links to the PR and the failing run where they exist
-   — a premise stop has neither, and its citation stands in for both. **Name the outcome
+   — a premise stop has neither, and its citation stands in for both.
+   **For a red check or an unexplained failure, the current hypothesis is the
+   diagnostician's parsed verdict**: dispatch `failure-diagnostician` with the
+   verbatim failure, save its answer to a file under the run directory, and
+   check it —
+
+   ```sh
+   node .claude/scripts/verdict.mjs check <report> failure-diagnostician
+   ```
+
+   — then carry the parsed verdict (word, `classification`, blockers,
+   evidence) as the hypothesis instead of writing the diagnosis from scratch,
+   with the verbatim failure output still in the comment beside it, covering
+   the "observed" clause the list above already names. A `PREMISE FALSE` or
+   exhausted-cap stop keeps the diagnosis the paragraph above already
+   describes (what the item claimed, or the round count).
+   **Name the outcome
    state in the same comment** — `incomplete` if the diagnosis cannot say **where** it
    stopped (§5: a thin diagnosis that still locates the wall is a `documented-stall`).
    Writing `incomplete` on your own task is uncomfortable and
@@ -847,29 +867,52 @@ four things, and a proposal missing any of them is not ready to file:
 3. the change, concretely enough to diff;
 4. how the next run would prove it worked — the observation that would differ.
 
-Filing is the adapter's `proposeTriage`, which the CLI deliberately does **not**
-expose — `index.mjs` never writes to the QUEUE (`next`, `list`, `hygiene` only), so
-that no accidental invocation can change what the next run is handed. Its one
-write is to the run journal above, and only into a directory the run declared —
-a trace of the selection, never a change to it. Call `proposeTriage` directly:
+Filing is the adapter's `proposeTriage`, reached through the one root-safe entry
+point `.claude/scripts/queue/propose.mjs` — never a relative `import()` typed by
+hand, which breaks the moment the session is standing in a subdirectory
+(`ERR_MODULE_NOT_FOUND` from the import, then an `ENOENT` from a cwd-relative
+`PLAN.md` that is not there). The CLI (`index.mjs`) still deliberately does
+**not** expose this — it never writes to the QUEUE (`next`, `list`, `hygiene`
+only), so that no accidental invocation can change what the next run is
+handed. `propose.mjs` resolves its config from its own location, exactly as
+`index.mjs` does, so the proposal lands in the project's real PLAN.md (or
+tracker) and the active board's own options travel with it rather than being
+typed by hand. Write the proposal to a file under the run directory, then run
+the script:
 
 ```bash
 node --input-type=module -e '
-  const a = await import("./.claude/scripts/queue/plan-md.mjs");   // or github-issues / jira
-  console.log(await a.proposeTriage({
-    finding: "<the journal line it came from>",
-    part:    "<skill | agent | hook | rule | AGENTS.md | CLAUDE.md | workflow>",
-    change:  "<concretely enough to diff>",
-    proof:   "<the observation that would differ next run>",
-    // a pair: what the probe touched, and what is concluded from it. The
-    // mechanism accepts a proposal without them; this procedure does not.
-    measured: "<the paths the probe actually exercised>",
-    inferred: "<the conclusion, citing only surfaces named in measured>",
-  }, { project: "<KEY>" }));   // jira only — the ACTIVE board's key: `queue/index.mjs board --json` → options.project;
-                               // plan-md and github-issues take no second argument
+  const fs = await import("node:fs/promises");
+  await fs.writeFile(
+    `${process.env.RIG_RUN_DIR}/proposal.json`,
+    JSON.stringify({
+      finding: "<the journal line it came from>",
+      part:    "<skill | agent | hook | rule | AGENTS.md | CLAUDE.md | workflow>",
+      change:  "<concretely enough to diff>",
+      proof:   "<the observation that would differ next run>",
+      // a pair: what the probe touched, and what is concluded from it. The
+      // mechanism accepts a proposal without them; this procedure does not.
+      measured: "<the paths the probe actually exercised>",
+      inferred: "<the conclusion, citing only surfaces named in measured>",
+    }),
+  );
 '
+# Root-anchored so the same command works whether the session is standing
+# at the repo root or in a subdirectory. Pinned in the generator's
+# test/template/loop-report-file.test.ts (absent in a generated rig) ›
+# "files when the documented command line runs, unmodified, from a project
+# subdirectory".
+node "$(git rev-parse --show-toplevel)/.claude/scripts/queue/propose.mjs" --file "$RIG_RUN_DIR/proposal.json"
 ```
 
+The result prints as one JSON line on stdout, and — because `RIG_RUN_DIR` is
+declared — the same result is also recorded as a `proposal` event in the run
+journal, so a failed filing is journalled as a failure instead of silently
+going nowhere. Pinned in the generator's `test/template/queue-propose.test.ts`
+(absent in a generated rig) › "files a proposal with a multiline finding from
+a project subdirectory, into the project-root PLAN.md" and › "journals a
+proposal event with ok: true on a successful filing under RIG_RUN_DIR".
+
 A proposal missing any of the four parts is refused rather than filed half-formed.
 
 **A finding can say what it measured and what it inferred, as two paired fields.**
@@ -920,9 +963,9 @@ rather than a step in the procedure: `plan-md` returns it when the plan file has
 no `## Operator queue` heading, because a proposal then has nowhere to land that
 the selection query cannot reach. Add the heading — never the Agent queue.
 
-One adapter needs the second argument the snippet above carries: `jira` requires
-`options.project` and throws rather than filing without it — loudly, so nothing
-is lost, but a call that drops it files nothing.
+`jira` still requires `options.project`, and still throws rather than filing
+without it — loudly, so nothing is lost — and there is no
+second argument left to hand-copy.
 
 🔴 **The loop proposes; the owner patches.** Self-applying a change to its own
 rulebook is how an unattended run drifts irreversibly, and it collides head-on

package/templates/agent-os/universal/.claude/skills/plan-slices/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: plan-slices
+description: Use when a task cannot be verified as one reviewable PR and splits into slices that are each independently verifiable on their own. Ships only with the opt-in workflow layer.
+allowed-tools: Read, Grep, Glob, Write, Edit
+---
+
+# Splitting a task into slices
+
+This applies when a task's change cannot be reviewed and verified as one PR,
+and decomposes into slices that are each independently verifiable — each
+slice stands on its own claim about behaviour, checked by its own test.
+
+Do not trigger it mechanically based on file or module count: a change
+that touches many files but makes one verifiable claim stays one PR, and a
+change touching few files but making several independent claims still
+splits.
+
+There is no planner role dispatched for this — the session writes the slice
+plan directly. For each slice, record:
+
+- the outcome the slice delivers, stated as a claim a test can check;
+- its own failing test, written by `test-writer` in the ordinary Red step;
+- the elevated paths it touches, if any (`AGENTS.md`'s elevated-paths block);
+- where it sits in the slice order, and what it depends on.
+
+Each slice then ships as its own PR through the ordinary flow —
+`.claude/rules/workflow.md` has the TDD cycle and the PR flow in full; this
+skill does not restate them.
+
+This skill ships only with the opt-in workflow layer.

package/templates/agent-os/universal/.claude/skills/pr-ship/SKILL.md

@@ -39,7 +39,7 @@ blockers.
      `test/template/gate-rounds.test.ts` — absent in a generated rig — ›
      "refuses to count a round on a dirty tree, and counts nothing".
 
-   The cap is **2 by default**, and no shipped `.claude/queue.json` carries the key
+   The cap is **3 by default**, and no shipped `.claude/queue.json` carries the key
    — the default lives in `core.mjs` as `DEFAULT_MAX_GATE_ROUNDS`. A project that
    wants a different cap sets `options.maxGateRounds` there, which in a rig whose
    `queue.json` is composed means changing what composes it, not editing the file.