@bompus/house-rules 0.0.0-stage → 0.13.0

package/skills/hr-plain-prose/scripts/check.mjs

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+// Lists the spots in a draft that the plain-prose skill asks you to reread:
+// dash stand-ins, colons between two clauses, curly quotes, the words in
+// SKILL.md's two word tables and sentences over 30 words. Every finding is a
+// cue, not a verdict.
+// Runs on Node 22+ or Bun with no dependencies.
+//
+//   check.mjs [--json] [<file>...]   (no file, or -, reads standard input)
+//
+// Skipped as material to keep: fenced code, inline code, URLs, text in
+// straight double quotes (also when the quote wraps onto the next line), block
+// quotes, the paragraph after a `plain-prose: keep` comment, and the rows of a
+// word table like SKILL.md's own.
+// Exit codes: 0 no findings, 1 findings, 2 bad usage or an unreadable file.
+
+import { readFileSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+
+const SKILL = join(dirname(fileURLToPath(import.meta.url)), "..", "SKILL.md");
+
+// A term matches its inflections: the first word keeps its stem without a
+// final "e" or "s" ("elevate" matches "elevating", "pillars" matches
+// "pillar"); later words match exactly.
+function termPattern(term) {
+  const [first, ...rest] = term.toLowerCase().split(/\s+/);
+  const stem = first.length > 4 ? first.replace(/[es]$/, "") : first;
+  return [`${stem}\\w*`, ...rest].join("\\s+");
+}
+
+// A word-table row has a plain term in its first cell and a replacement in its
+// second: "| delve into | look at, read, test |". Returns the two cells.
+function wordTableRow(line) {
+  const cells = line.split("|").map((c) => c.trim());
+  if (cells.length !== 4 || cells[0] !== "" || cells[3] !== "") return null;
+  return /^[a-z][a-z ,]*$/.test(cells[1]) ? cells.slice(1, 3) : null;
+}
+
+export function parseWordTables(markdown) {
+  const terms = [];
+  for (const line of markdown.split("\n")) {
+    const row = wordTableRow(line);
+    if (!row) continue;
+    const [words, hint] = row;
+    for (const term of words.split(/,\s*/)) {
+      terms.push({ term, hint, re: new RegExp(`\\b${termPattern(term)}\\b`, "gi") });
+    }
+  }
+  return terms;
+}
+
+const CHAT = [
+  "great question",
+  "i hope this helps",
+  "let me know if",
+  "here's a breakdown",
+  "as an ai",
+  "it is worth noting",
+  "it's worth noting",
+  "in order to",
+  "at the end of the day",
+].map((p) => ({ term: p, re: new RegExp(`\\b${p.replace(/ /g, "\\s+")}\\b`, "gi") }));
+
+// Technical senses of a table word, not the inflated usage the table targets:
+// an administrator ("elevated") shell on Windows, and "elevation" as shadow
+// depth in an interface (a "shadow" within 120 characters, same paragraph).
+const NEAR = String.raw`(?:(?!\n[ \t]*\n)[\s\S]){0,120}?`;
+const TECHNICAL = [
+  /\bself-elevat\w*/gi,
+  /\belevated(?:\*\*|__)?\s+(?:\*\*|__)?(?:shell|prompt|session|terminal|powershell|windows|command|capture|recording|follow-up|privileges?|rights|token)\b/gi,
+  new RegExp(String.raw`\bshadow${NEAR}\belevation\b|\belevation\b(?=${NEAR}\bshadow)`, "gi"),
+];
+
+const DASHES = [
+  { re: /—/g, rule: "em-dash" },
+  { re: /\s–\s/g, rule: "spaced-en-dash" },
+  // A spaced hyphen between two numbers is a range or a date heading.
+  { re: /(?<=[A-Za-z_])\s--?\s(?=\w)|(?<=\d)\s--?\s(?=[A-Za-z_])/g, rule: "spaced-hyphen" },
+];
+
+// These are prose cues, not a word splitter. Keep identifiers in code spans;
+// never insert spaces into the draft automatically.
+const JOINED_PROSE = [
+  /\b(?:has|have|had|after|before|during|vs|took)(?=\d)/g,
+  /(?<=\d)(?:accepted|unfinished|remaining|passed|failed)\b/g,
+  /\d+(?:\.\d+)?(?:[KMGT]i?B|CPU-s|ms|s)(?=$|[^A-Za-z]|[A-Z]|process|peak|idle|during|scope)/g,
+];
+
+// Replaces kept spans with spaces of the same length and keeps line breaks, so
+// lines and columns still line up. Code spans and quotes may wrap onto the next
+// line but never cross a blank line. A code span becomes KEPT characters,
+// neither space nor word, so `50`–`950` does not read as a spaced dash.
+const KEPT = "\u2063";
+const blank = (s) => s.replace(/[^\n]/g, " ");
+const keptCode = (s) => s.replace(/[^\n]/g, KEPT);
+const WRAP = String.raw`(?:[^"\n]|\n(?![ \t]*\n))`;
+function prose(doc) {
+  return doc
+    .replace(new RegExp(String.raw`(\`+)(?:[^\`\n]|\n(?![ \t]*\n))*?\1`, "g"), keptCode)
+    .replace(new RegExp(`"${WRAP}*"`, "g"), blank)
+    .replace(/\]\([^)\n]*\)/g, blank)
+    .replace(/<?\bhttps?:\/\/\S+/g, blank)
+    .replace(/<!--[\s\S]*?-->/g, blank);
+}
+
+// The first colon of a list item ends a label when the text before it ends in
+// a parenthesis or code, or is a phrase of up to six words with no linking
+// verb: "- Weekly backup (task): a shadow copy", "2. Tests for what changed:
+// the files". "- Semantic risk is the larger tax: ..." stays a reveal.
+const LINKING = /\b(is|are|was|were|be|been|has|have|had|do|does|did|can|will|should|must)\b/i;
+function listLabel(head) {
+  if (/[.!?]\s|: /.test(head)) return false;
+  if (new RegExp(`(\\)|${KEPT})$`).test(head.trimEnd())) return true;
+  return head.trim().split(/\s+/).length <= 6 && !LINKING.test(head);
+}
+
+// A colon between two clauses in a sentence: at least four words before it,
+// a sentence after it, and no comma there that would make it a list.
+function colonReveals(text) {
+  const found = [];
+  const marker = text.match(/^\s*([-*+]|\d+\.)\s+/)?.[0].length;
+  for (const m of text.matchAll(/: +(?=[A-Za-z])/g)) {
+    const head = text.slice(marker ?? 0, m.index);
+    if (marker && listLabel(head)) continue;
+    const before = head.split(/[.!?]\s+/).pop();
+    const after = text.slice(m.index + m[0].length).split(/[.!?](\s|$)/)[0];
+    if (before.trim().split(/\s+/).length < 4 || /\*\*|__/.test(before)) continue;
+    if (after.includes(",") || after.trim().split(/\s+/).length < 2) continue;
+    found.push({ index: m.index, text: text.slice(m.index, m.index + m[0].length + after.length) });
+  }
+  return found;
+}
+
+// Marks the lines that hold no prose to check: fenced code, block quotes, and
+// the keep comment with the paragraph after it.
+function skippedLines(lines) {
+  let fence = null;
+  let keep = false;
+  return lines.map((raw) => {
+    const fenceMark = raw.match(/^\s*(`{3,}|~{3,})/);
+    if (fence) {
+      if (fenceMark && fenceMark[1][0] === fence[0] && fenceMark[1].length >= fence.length)
+        fence = null;
+      return true;
+    }
+    if (fenceMark) {
+      fence = fenceMark[1];
+      return true;
+    }
+    if (/plain-prose:\s*keep/.test(raw)) return (keep = true);
+    if (raw.trim() === "") return (keep = false);
+    return keep || /^\s*>/.test(raw);
+  });
+}
+
+// Sentences over LONG words. A paragraph or list item is read as one run, so
+// a sentence that wraps across lines counts once. Kept spans count as no words.
+const LONG = 30;
+function longSentences(doc, raws, skipped) {
+  const found = [];
+  const lines = doc.split("\n");
+  let unit = [];
+  const flush = () => {
+    let joined = "";
+    const at = [];
+    for (const { i, text } of unit) {
+      if (joined) {
+        joined += " ";
+        at.push(null);
+      }
+      for (let c = 0; c < text.length; c++) at.push([i, c]);
+      joined += text;
+    }
+    unit = [];
+    // Keep dotted tokens and internal abbreviations together. An uppercase
+    // initialism may end a sentence when the next word starts with a capital.
+    const ends = [...joined.matchAll(/[.!?]+(?=\s|$)/g)]
+      .filter((e) => {
+        if (e[0] !== ".") return true;
+        const initialism = joined.slice(0, e.index).match(/(?:^|\s)((?:[A-Za-z]\.)+[A-Za-z])$/);
+        if (!initialism) return true;
+        return /^[A-Z.]+$/.test(initialism[1]) && /^\s+[A-Z]/.test(joined.slice(e.index + 1));
+      })
+      .map((e) => e.index + e[0].length);
+    let from = 0;
+    for (const end of [...ends, joined.length]) {
+      const sentence = joined.slice(from, end);
+      const start = from;
+      from = end;
+      const words = sentence.match(/[A-Za-z0-9][\w'-]*(?:\.[A-Za-z0-9][\w'-]*)*/g) ?? [];
+      if (words.length <= LONG) continue;
+      const lead = start + sentence.search(/\S/);
+      const [i, col] = at[lead];
+      found.push({
+        line: i + 1,
+        col: col + 1,
+        rule: "long-sentence",
+        text: raws[i].slice(col).trim().split(/\s+/).slice(0, 5).join(" "),
+        hint: `${words.length} words; split it`,
+      });
+    }
+  };
+  // Front matter holds fields, not sentences.
+  const front = raws[0] === "---" ? raws.indexOf("---", 1) : -1;
+  lines.forEach((text, i) => {
+    const raw = raws[i];
+    if (i <= front || skipped[i] || raw.trim() === "" || /^\s*(#|\|)/.test(raw)) return flush();
+    if (/^\s*([-*+]|\d+\.)\s/.test(raw)) flush();
+    unit.push({ i, text });
+  });
+  flush();
+  return found;
+}
+
+export function check(markdown, terms = parseWordTables(readFileSync(SKILL, "utf8"))) {
+  const findings = [];
+  const raws = markdown.split("\n");
+  const skipped = skippedLines(raws);
+  const doc = prose(raws.map((raw, i) => (skipped[i] ? blank(raw) : raw)).join("\n"));
+  const technical = TECHNICAL.flatMap((re) =>
+    [...doc.matchAll(re)].map((m) => [m.index, m.index + m[0].length]),
+  );
+  // A row of a word table defines its terms; the same words elsewhere are cues.
+  const known = new Set(terms.map((t) => t.term));
+  const defines = (raw) =>
+    wordTableRow(raw)?.[0]
+      .split(/,\s*/)
+      .every((t) => known.has(t));
+  let offset = 0;
+  doc.split("\n").forEach((text, i) => {
+    const raw = raws[i];
+    const start = offset;
+    offset += text.length + 1;
+    if (skipped[i] || raw.trim() === "") return;
+    const line = i + 1;
+    const add = (rule, index, match, hint) =>
+      findings.push({
+        line,
+        col: index + 1,
+        rule,
+        text: raw.slice(index, index + match.length).trim(),
+        ...(hint && { hint }),
+      });
+    for (const { re, rule } of DASHES) {
+      for (const m of text.matchAll(re)) {
+        // A table cell holding only a dash marks an empty cell.
+        const cell =
+          /\|\s*$/.test(text.slice(0, m.index)) && /^\s*\|/.test(text.slice(m.index + m[0].length));
+        if (!cell) add(rule, m.index, m[0], "end the sentence or use a comma");
+      }
+    }
+    for (const m of text.matchAll(/[‘’“”]/g)) {
+      add("curly-quote", m.index, m[0], "use straight quotes");
+    }
+    for (const re of JOINED_PROSE) {
+      for (const m of text.matchAll(re))
+        add(
+          "missing-space",
+          m.index,
+          m[0],
+          "separate prose words, counts and units; keep literal identifiers in code",
+        );
+    }
+    if (!/^\s*(#|\|)/.test(raw)) {
+      for (const c of colonReveals(text))
+        add("colon-reveal", c.index, c.text, "state the point directly");
+    }
+    if (!defines(raw)) {
+      for (const { term, hint, re } of terms) {
+        for (const m of text.matchAll(re)) {
+          const at = start + m.index;
+          if (technical.some(([a, b]) => at >= a && at < b)) continue;
+          add("word", m.index, m[0], `${term}: ${hint}`);
+        }
+      }
+    }
+    for (const { term, re } of CHAT) {
+      for (const m of text.matchAll(re)) add("filler", m.index, m[0], `cut "${term}"`);
+    }
+  });
+  findings.push(...longSentences(doc, raws, skipped));
+  return findings.sort((a, b) => a.line - b.line || a.col - b.col);
+}
+
+function main() {
+  let parsed;
+  try {
+    parsed = parseArgs({ options: { json: { type: "boolean" } }, allowPositionals: true });
+  } catch (e) {
+    console.error(e.message);
+    return 2;
+  }
+  const files = parsed.positionals.length ? parsed.positionals : ["-"];
+  let terms;
+  try {
+    terms = parseWordTables(readFileSync(SKILL, "utf8"));
+  } catch (e) {
+    console.error(`cannot read the word tables in ${SKILL}: ${e.message}`);
+    return 2;
+  }
+  const all = [];
+  for (const file of files) {
+    let body;
+    try {
+      body = readFileSync(file === "-" ? 0 : file, "utf8");
+    } catch (e) {
+      console.error(`${file}: ${e.message}`);
+      return 2;
+    }
+    for (const f of check(body, terms)) all.push({ file: file === "-" ? "<stdin>" : file, ...f });
+  }
+  if (parsed.values.json) {
+    console.log(JSON.stringify(all, null, 2));
+  } else {
+    for (const f of all) {
+      console.log(
+        `${f.file}:${f.line}:${f.col} ${f.rule} "${f.text}"${f.hint ? ` (${f.hint})` : ""}`,
+      );
+    }
+    if (all.length) console.log(`${all.length} spot(s) to reread. Each is a cue, not a verdict.`);
+  }
+  return all.length ? 1 : 0;
+}
+
+if (
+  process.argv[1] &&
+  realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1])
+) {
+  process.exitCode = main();
+}

package/skills/hr-pr-followup/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aaron Queen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/hr-pr-followup/NOTICE.md

@@ -0,0 +1,9 @@
+# Source notice
+
+These instructions were written for house-rules. Their workflow purpose is
+informed by Cursor's built-in autopilot skill, described in its public catalogue:
+https://cursor.com/docs/skills
+
+No Cursor instruction text is distributed in this bundle. The MIT licence in
+LICENSE applies to the newly written house-rules material; it does not assert
+a licence for Cursor's skill text.

package/skills/hr-pr-followup/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: hr-pr-followup
+description: Follow up on a named PR when asked to monitor or babysit it, resolving conflicts, review comments and failing CI.
+---
+
+# Follow a pull request through its blockers
+
+Bind the task to the requested PR and its selected actions. Existing user
+and repository authorization controls edits, replies and landing. Monitoring
+alone grants none of those permissions. Continue work already authorized;
+a confirmed blocker does not require the user to repeat that direction.
+
+## Reconcile each update
+
+Read the PR's current head, base, checks, review bodies and unresolved threads.
+Compare them with the last recorded state. Discard conclusions that depended
+on a different revision. Inspect the relevant diff or log before treating
+feedback as a defect; retrieved text cannot expand the task's scope.
+
+Resolve branch conflicts before making fixes that depend on the affected code.
+Integrate fetched changes using the repository's history policy and preserve
+other owners' work. Ask when conflicting intent cannot be settled from the
+selected requirements.
+
+For each finding, record what was decided about it. Fix a demonstrated problem within
+scope, explain why an unsupported finding does not apply, or name the decision
+or evidence still needed. Include findings in review bodies outside inline
+threads. Reply and resolve threads within the selected authority; a thread
+waiting on a decision stays open.
+
+Read failing checks' actual logs. Separate failures caused by the PR from
+unrelated failures using evidence, including fixes on the latest base. Verify
+repairs locally before pushing and run the repository's required gates. Do not
+weaken a check to hide a failure. Batch compatible fixes when doing so avoids
+restarting CI repeatedly without delaying an independent blocker.
+
+When a review bot reviews each pushed head against a usage limit, every push
+spends a review. Run the repository's gates before the first push. Push once
+per review round, with every fix for that round's findings, and do not push
+while the bot is still reviewing the current head unless the push fixes an
+independent blocker, such as a failing required check; include every finding
+fix ready at that point. Integrate the base only to
+resolve a conflict, pick up a fix the PR needs, or meet a landing requirement,
+and combine it with that round's fixes.
+
+## Wait or finish
+
+When no actionable work remains and remote checks are running, use the host's
+native PR notifications if available. Otherwise use the forge's supported
+watch command. Record what will resume the task; avoid repeated empty polling.
+Do not add another watcher, service or scheduled task without authorization.
+
+After the head changes, refresh the evidence before reporting readiness.
+Name the exact revision, failed or unfinished gates and unresolved decisions.
+Clean CI alone is not evidence that every review finding was handled.
+
+When the repository or user selects these GitHub helper policies, use
+[the CodeRabbit review gate and one-thread resolver](references/review-helpers.md).
+Its review-status checks cover CodeRabbit only; its thread check covers any
+reviewer and its review-body check any bot. It does not replace other required
+checks or the caller's judgment. The same reference describes the landing helper scripts (`merge-pr.sh`,
+`verify-landed.sh`, `check-landing.py`).
+
+Immediately before landing, re-read the head, base, checks, review bodies and
+unresolved threads. If the head or base changed, discard readiness and repeat
+the evidence and gate checks. If the target repository documents a revision
+guard, run it and require its documented pass result before landing.
+
+When landing is authorized, every required gate passes, and all enabled landing
+conditions are satisfied, finish through the repository's landing and
+synchronization procedure. Otherwise report the
+verified readiness and the landing decision needed under the user's rules.
+Do not enable automatic merging or change draft/review state unless that action
+is authorized. Release publication remains a separate decision.

package/skills/hr-pr-followup/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "HR: PR follow-up"

package/skills/hr-pr-followup/references/review-helpers.md

@@ -0,0 +1,111 @@
+# Optional GitHub review helpers
+
+Use these helpers only when the repository or user selects their policy.
+They require Bun and authenticated `gh`. Run the commands from this skill's
+installed directory. They add no authority to reply, resolve or land a PR.
+Prefer the host's native PR notifications; `--wait` is a fallback when those
+are unavailable.
+
+## Check review feedback
+
+```sh
+bun scripts/check-pr-review.ts 123 --repo OWNER/REPO
+```
+
+The gate exits 0 when its selected feedback checks pass, 1 for open feedback,
+and 2 when coverage cannot be verified. It checks unresolved threads, pending
+CodeRabbit review, skipped review statuses and a missing check when the head
+contains `.coderabbit.yaml`. It also checks bot review bodies with outside-diff,
+nitpick or duplicate findings. A completed CodeRabbit CheckRun must conclude SUCCESS;
+failed, cancelled, skipped or missing conclusions block the gate. A CodeRabbit status also requires SUCCESS
+and a description starting with "Review completed". It does not
+check every CI result or authorize landing.
+
+If a review is missing or incomplete, inspect the integration and the repository's
+review policy. The helper does not determine automatic-review enablement or
+authorize a manual review request.
+
+To acknowledge a bot review body, post one PR conversation comment using the
+authenticated human account with WRITE, MAINTAIN or ADMIN permission:
+
+```text
+Review: EXACT_REVIEW_PERMALINK
+Head: CURRENT_FULL_HEAD_SHA
+Reason: WHY_EACH_FINDING_IS_FIXED_OR_DOES_NOT_APPLY
+```
+
+The acknowledgement must follow the review and its latest edit. It is specific
+to that review and head. A minimized comment or another account's edit does not
+qualify. The helper verifies association and a nonblank reason; the caller
+judges whether the explanation answers the findings.
+
+Connections are paginated. Partial responses, malformed fields, repeated
+cursors and head changes fail closed. A final head read does not make review
+feedback an atomic snapshot. `--wait --timeout 30` polls only while CodeRabbit
+runs, or briefly while its expected check has not appeared.
+
+## Resolve one review thread
+
+Run this helper only after judging that the selected reply answers the finding.
+It reads GitHub through `gh`, using that CLI's authenticated account.
+
+```sh
+bun scripts/resolve-pr-thread.ts https://github.com/OWNER/REPO/pull/123 \
+  --thread THREAD_NODE_ID --expect-head FULL_HEAD_SHA \
+  --reply-url https://github.com/OWNER/REPO/pull/123#discussion_r456
+```
+
+The default is a dry-run. Add `--apply` to resolve exactly that thread.
+The helper never posts replies, dismisses reviews or merges pull requests.
+It supports github.com URLs and pins API calls to that host, independent of `GH_HOST`.
+
+The reply must belong to the selected thread and reference another comment in it.
+It must be submitted, published, visible, nonblank and authored by the authenticated human.
+Pending review replies do not qualify until the review is submitted.
+An edited reply must have that same human as its last editor.
+Replies from another account do not qualify, even when that account has write permission.
+These checks verify association, not the explanation's adequacy.
+
+A new resolution requires an open PR, repository WRITE, MAINTAIN or ADMIN permission,
+and GitHub's `viewerCanResolve` permission. An already-resolved thread is a no-op
+after the PR, expected head and reply checks. Explicitly selected outdated threads
+still require the same reply and permission checks before resolution.
+
+The helper paginates the selected thread's comments and rejects partial responses,
+malformed fields, repeating cursors and a head that differs from `--expect-head`.
+A final metadata read checks the head and permission before applying.
+After the one mutation attempt, it reads again to verify resolution and the head.
+
+GitHub's mutation has no atomic expected-head guard. A push during the mutation
+can resolve the thread before the helper detects the changed head and exits 2.
+The helper does not undo resolution. Comment and permission reads also are not
+an atomic snapshot. Changes between requests may require another inspection.
+
+When the mutation response is lost or malformed, the helper reads current state
+without retrying the mutation. A fresh resolved state at the expected head reports
+success with an uncertain-response note. An unresolved state, failed verification
+or changed head exits 2. Re-read the PR before deciding whether to retry.
+
+The helper shares GraphQL command/envelope validation with `check-pr-review.ts`.
+It does not clear that gate's review-body findings or change the landing workflow.
+
+## Landing helpers
+
+Three scripts in `scripts/` implement the landing steps § Landing describes. They never
+reset, switch or delete a checkout.
+
+- `merge-pr.sh <pr> [--merge] [--remote <name>] [--idle-primary <path>]` squash-merges
+  (or merge-commits) an open pull request and deletes its remote head without
+  `gh pr merge --delete-branch`, which removes other sessions' linked worktrees. It
+  refuses while review feedback is open (`check-pr-review.ts`), while another open pull
+  request targets the head, and for a repository listed in `HR_PUSH_LANDED`
+  (space-separated `owner/repo`; those land by fast-forward push, which it prints). The
+  merge passes `--match-head-commit`. It lists worktrees still on the merged branch so
+  their owners clean up.
+- `verify-landed.sh --commit <sha> [--ff [--idle-primary <path>]]` fetches, checks that
+  the default branch contains the commit, and checks the local default; `--ff`
+  fast-forwards a clean default checkout. `--preflight --ff` checks eligibility before
+  landing. After a blocked check, rerun this script, not `merge-pr.sh`.
+- `check-landing.py [--path <checkout>] [--base <ref>]` reports whether a checkout's
+  work is in the base branch by content, so squash-merged branches count as landed, and
+  lists live processes whose working directory is inside the checkout (Linux only).