kanbot 0.2.0 → 0.4.0

package/src/commands/doctor.ts

@@ -1,22 +1,36 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { defineCommand } from "citty";
-import { loadAgents } from "../agents/load.ts";
+import { loadAgents, missingSkills } from "../agents/load.ts";
 import { sync } from "../agents/sync.ts";
+import { capabilitySummary, findCapability } from "../capabilities.ts";
 import { loadConfig, writeConfigSchema } from "../config.ts";
 import { git } from "../daemon/git.ts";
 import { describeError } from "../errors.ts";
 import { copilotReviewRule } from "../github/api.ts";
+import { appKeyPath, appTokens } from "../github/app.ts";
 import { Gh, run } from "../github/gh.ts";
 import {
 	boardWorkflows,
 	loadBoard,
 	missingColumns,
 } from "../github/project.ts";
+import {
+	codexSupports,
+	type McpServer,
+	readMcpServers,
+} from "../providers/mcp.ts";
 import { NEW_SUFFIX, pendingMerges, planUpgrade } from "../templates.ts";
 import { REPO_LABELS } from "./board.ts";
 
-type Check = { name: string; ok: boolean; detail?: string; fix?: string };
+type Check = {
+	name: string;
+	ok: boolean;
+	/** Shown with a warning mark; never fails doctor. */
+	warn?: boolean;
+	detail?: string;
+	fix?: string;
+};
 
 async function cmd(args: string[]) {
 	const p = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
@@ -49,7 +63,7 @@ export default defineCommand({
 		const add = (c: Check) => {
 			checks.push(c);
 			console.log(
-				`${c.ok ? "✔" : "✖"} ${c.name}${c.detail ? ` — ${c.detail}` : ""}${!c.ok && c.fix ? `\n    fix: ${c.fix}` : ""}`,
+				`${c.warn ? "!" : c.ok ? "✔" : "✖"} ${c.name}${c.detail ? ` — ${c.detail}` : ""}${!c.ok && c.fix ? `\n    fix: ${c.fix}` : ""}`,
 			);
 		};
 
@@ -93,6 +107,12 @@ export default defineCommand({
 				detail: s.out.split("\n")[0],
 				fix: "codex login",
 			});
+			add({
+				name: "codex workers ignore ~/.codex/config.toml",
+				ok: true,
+				detail:
+					"models come from agent frontmatter, MCP servers from .mcp.json",
+			});
 		}
 
 		try {
@@ -104,10 +124,11 @@ export default defineCommand({
 			});
 			const needed = [
 				"planner",
-				"reviewer-code",
-				"reviewer-spec",
+				"reviewer",
+				"acceptance-reviewer",
 				"fixer",
-				...Object.values(config.implementers),
+				"implementer",
+				...Object.values(config.implementers ?? {}),
 			];
 			const missing = [...new Set(needed)].filter(
 				(n) => !agents.some((a) => a.name === n),
@@ -116,7 +137,43 @@ export default defineCommand({
 				name: "agents referenced by config exist",
 				ok: !missing.length,
 				detail: missing.join(", ") || undefined,
+				fix: "kanbot upgrade",
+			});
+			if (config.implementers)
+				add({
+					name: "implementers is deprecated",
+					ok: true,
+					warn: true,
+					detail:
+						"implement uses `implementer`; map craft with capabilities instead",
+					fix: "remove implementers from .kanbot/config.yml",
+				});
+			const noSkill = missingSkills(root, agents);
+			add({
+				name: "skills referenced by agents exist",
+				ok: !noSkill.length,
+				detail: noSkill.join(", ") || undefined,
+				fix: "add them to .agents/skills or remove them from the agent's `skills`",
+			});
+			add({
+				name: "capabilities",
+				ok: true,
+				detail: capabilitySummary(config.capabilities),
 			});
+			// Only problems get their own line.
+			for (const [name, c] of Object.entries(config.capabilities)) {
+				const found = findCapability(root, agents, c.use);
+				if (found === "skill" || found === "agent") continue;
+				add({
+					name: `capability ${name} → ${c.use}`,
+					ok: found !== null,
+					warn: found !== null,
+					detail: found
+						? `${found} agent, works on ${found} only`
+						: "not found",
+					fix: "add the skill to .agents/skills or the agent to .kanbot/agents",
+				});
+			}
 			const stale = await sync(root, agents, { check: true });
 			add({
 				name: "generated agent files up to date",
@@ -133,6 +190,24 @@ export default defineCommand({
 			add({ name: "agents", ok: false, ...explain(e) });
 		}
 
+		const servers = await readMcpServers(root);
+		const names = Object.keys(servers);
+		const skipped =
+			config.provider === "codex"
+				? names.filter((n) => !codexSupports(servers[n] as McpServer))
+				: [];
+		add({
+			name: "MCP servers for workers (.mcp.json)",
+			ok: true,
+			warn: skipped.length > 0,
+			detail: [
+				names.join(", ") || "none",
+				skipped.length ? `codex can't run: ${skipped.join(", ")}` : "",
+			]
+				.filter(Boolean)
+				.join("; "),
+		});
+
 		const plan = await planUpgrade(root);
 		const behind = plan.changes.filter((c) =>
 			["add", "update", "conflict"].includes(c.action),
@@ -236,6 +311,40 @@ export default defineCommand({
 			fix: "kanbot board create",
 		});
 
+		const { mode, app } = config.identity;
+		if (mode === "app") {
+			add({
+				name: "kanbot app set",
+				ok: app !== null,
+				detail: app ? `${app.slug} (id ${app.id})` : undefined,
+				fix: "kanbot app create",
+			});
+			if (app) {
+				const key = appKeyPath(app.id);
+				add({
+					name: "kanbot app private key",
+					ok: existsSync(key),
+					detail: key,
+					fix: "kanbot app create, or copy the key from the machine that created the app",
+				});
+				if (existsSync(key)) {
+					try {
+						await appTokens(app, config.repo)();
+						add({ name: `kanbot app installed on ${config.repo}`, ok: true });
+					} catch (e) {
+						add({
+							name: `kanbot app installed on ${config.repo}`,
+							ok: false,
+							...explain(
+								e,
+								`https://github.com/apps/${app.slug}/installations/new`,
+							),
+						});
+					}
+				}
+			}
+		}
+
 		if (config.review.copilot) {
 			const rule = await copilotReviewRule(gh, config.baseBranch).catch(
 				() => null,

package/src/commands/init.ts

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { defineCommand } from "citty";
 import { loadAgents } from "../agents/load.ts";
 import { sync } from "../agents/sync.ts";
+import { askCapabilities, compact, ownWorkers } from "../capabilities.ts";
 import { configPath, saveConfig, writeConfigSchema } from "../config.ts";
 import { UserError } from "../errors.ts";
 import { run } from "../github/gh.ts";
@@ -79,6 +80,16 @@ export default defineCommand({
 			log.info(
 				`+ .kanbot/config.yml (${repo.nameWithOwner}, base ${repo.defaultBranchRef.name})`,
 			);
+			// Only ask when someone can answer.
+			if (process.stdin.isTTY) {
+				const caps = askCapabilities(await ownWorkers(root), prompt);
+				if (Object.keys(caps).length) {
+					await saveConfig(root, { capabilities: compact(caps) } as never);
+					log.info(
+						`~ .kanbot/config.yml (capabilities: ${Object.keys(caps).join(", ")})`,
+					);
+				}
+			}
 		}
 
 		const codeowners = join(root, ".github", "CODEOWNERS");
@@ -101,10 +112,11 @@ export default defineCommand({
 Next steps:
   1. Review AGENTS.md and fill in .agents/skills/project-conventions/SKILL.md
   2. Adjust .github/workflows/ci.yml to your stack (agents fix failing CI)
-  3. kanbot board create        # creates the project board and labels
-  4. kanbot doctor              # checks auth, board, generated files
+  3. Map your own skills under capabilities in .kanbot/config.yml (kanbot-guide can help)
+  4. kanbot board create        # board and labels; enable the workflows it prints
   5. Commit and push these files to the default branch (agents work from it)
-  6. kanbot run                 # start the loop (or kanbot run --once --dry-run)`);
+  6. kanbot doctor              # checks auth, board, generated files
+  7. kanbot run                 # start the loop (or kanbot run --once --dry-run)`);
 	},
 });
 

package/src/commands/skills.ts

@@ -6,7 +6,7 @@ import { log } from "../log.ts";
 import { listTemplates } from "../templates.ts";
 
 /** Skills that work outside a kanbot repo, so they can be installed per user. */
-export const GLOBAL_SKILLS = ["kanbot-idea"];
+export const GLOBAL_SKILLS = ["kanbot-idea", "kanbot-guide"];
 
 /** User-level skill folders: Claude Code reads the first, Codex the second. */
 export const globalSkillDirs = (home = homedir()) => ({

package/src/commands/sync.ts

@@ -8,7 +8,7 @@ export default defineCommand({
 	meta: {
 		name: "sync",
 		description:
-			"Generate .claude/agents, .codex/agents, permissions and the config schema",
+			"Generate .claude/agents, .codex/agents, permissions and the config schema from .kanbot/agents",
 	},
 	args: {
 		check: {

package/src/commands/upgrade.ts

@@ -1,8 +1,15 @@
+import { existsSync } from "node:fs";
 import { defineCommand } from "citty";
 import pkg from "../../package.json" with { type: "json" };
 import { loadAgents } from "../agents/load.ts";
 import { sync } from "../agents/sync.ts";
-import { writeConfigSchema } from "../config.ts";
+import { compact, legacyCapabilities } from "../capabilities.ts";
+import {
+	configPath,
+	loadConfig,
+	saveConfig,
+	writeConfigSchema,
+} from "../config.ts";
 import { log } from "../log.ts";
 import {
 	applyUpgrade,
@@ -48,9 +55,21 @@ export default defineCommand({
 				);
 		}
 		if (!plan.changes.length) log.info("Templates are up to date.");
+		const caps = existsSync(configPath(root))
+			? legacyCapabilities(root, (await loadConfig(root)).capabilities)
+			: null;
+		if (caps)
+			console.log(
+				`\nMapped skills you have to capabilities in .kanbot/config.yml:\n${Object.entries(
+					caps,
+				)
+					.map(([n, c]) => `  ${n}: ${c.use}`)
+					.join("\n")}`,
+			);
 		if (args["dry-run"]) return;
 
 		await applyUpgrade(root, plan);
+		if (caps) await saveConfig(root, { capabilities: compact(caps) } as never);
 		const generated = await sync(root, await loadAgents(root));
 		if (await writeConfigSchema(root))
 			generated.push(".kanbot/config.schema.json");

package/src/config.ts

@@ -17,6 +17,36 @@ export type ColumnKey = (typeof COLUMN_KEYS)[number];
 export const JOB_KINDS = ["fix", "review", "plan", "implement"] as const;
 export type JobKind = (typeof JOB_KINDS)[number];
 
+export const RESERVED_CAPABILITIES = ["verify", "review", "preview"] as const;
+
+const CapabilityObject = z.object({
+	use: z
+		.string()
+		.min(1)
+		.describe(
+			"Skill in .agents/skills or agent in .kanbot/agents that does the work.",
+		),
+	when: z
+		.string()
+		.optional()
+		.describe("When it applies, e.g. `Changes to UI users see`."),
+	required: z
+		.boolean()
+		.default(false)
+		.describe("A miss when it applies blocks acceptance review."),
+});
+
+/** `verify: verify-ui` is short for `verify: { use: verify-ui }`. */
+export const Capability = z.union([
+	z
+		.string()
+		.min(1)
+		.describe("Skill or agent name, short for `{ use: <name> }`.")
+		.transform((use) => CapabilityObject.parse({ use })),
+	CapabilityObject,
+]);
+export type Capability = z.output<typeof Capability>;
+
 export const ConfigSchema = z.object({
 	provider: z
 		.enum(["claude", "codex"])
@@ -78,15 +108,15 @@ export const ConfigSchema = z.object({
 		.describe("Per-job timeout in minutes."),
 	implementers: z
 		.record(z.string(), z.string())
-		.default({
-			frontend: "implementer-frontend",
-			backend: "implementer-backend",
-			docs: "implementer-docs",
-			infra: "implementer-technical",
-			default: "implementer-backend",
-		})
+		.optional()
 		.describe(
-			"Maps a type:<key> label to an agent. `default` is the fallback.",
+			"Deprecated: implement always uses `implementer`. While set, maps a type:<key> label to an agent, with `default` as the fallback. Use capabilities instead.",
+		),
+	capabilities: z
+		.record(z.string().regex(/^[a-z][a-z0-9-]*$/), Capability)
+		.default({})
+		.describe(
+			"Needs mapped to the repo's own skills or agents. Reserved: verify (prove acceptance criteria), review (technical review), preview (something a human can try). Other names are yours.",
 		),
 	review: z
 		.object({
@@ -112,6 +142,40 @@ export const ConfigSchema = z.object({
 				),
 		})
 		.prefault({}),
+	identity: z
+		.object({
+			mode: z
+				.enum(["user", "app"])
+				.default("user")
+				.describe(
+					"Who kanbot talks as. `user`: your account. `app`: a kanbot GitHub App, so its comments and PRs show as a bot. Commits are always yours.",
+				),
+			app: z
+				.object({
+					id: z.number().int().describe("GitHub App ID."),
+					slug: z.string().describe("App slug, as in github.com/apps/<slug>."),
+				})
+				.nullable()
+				.default(null)
+				.describe(
+					"Set by `kanbot app create`. The private key lives in ~/.kanbot/apps/<id>.pem.",
+				),
+		})
+		.prefault({}),
+	merge: z
+		.object({
+			onApproval: z
+				.boolean()
+				.default(false)
+				.describe(
+					"Merge a kanbot PR when a collaborator approves it, checks pass and agent review is done. Merges as you. Needs identity.mode app to approve your own kanbot PRs.",
+				),
+			method: z
+				.enum(["squash", "merge", "rebase"])
+				.default("squash")
+				.describe("Merge method used for approved PRs."),
+		})
+		.prefault({}),
 	codex: z
 		.object({
 			networkAccess: z

package/src/daemon/derive.ts

@@ -73,8 +73,10 @@ export type Action =
 	| { kind: "move"; item: Item; to: ColumnKey; why: string }
 	| { kind: "label"; number: number; add: string[]; remove: string[] }
 	| { kind: "agentReviewed"; item: Item; pr: PR }
+	| { kind: "merge"; item: Item; pr: PR; by: string }
 	| { kind: "compare"; item: Item; prs: PR[] }
 	| { kind: "needsHuman"; number: number; why: string }
+	| { kind: "openQuestions"; item: Item; questions: string[] }
 	| { kind: "resetFailures"; prefix: string }
 	| { kind: "cleanup"; number: number };
 
@@ -161,6 +163,52 @@ export function copilotThreads(pr: PR) {
 	});
 }
 
+/**
+ * Who approved the PR's current head, if anyone. A trusted reviewer's pending
+ * change request blocks it, and approvals of older commits don't count.
+ */
+export function approvedBy(
+	pr: PR,
+	trusted: ReadonlySet<string>,
+): string | null {
+	const verdicts = pr.verdicts.filter((v) => trusted.has(v.author));
+	if (verdicts.some((v) => v.state === "CHANGES_REQUESTED")) return null;
+	return (
+		verdicts.find((v) => v.state === "APPROVED" && v.commit === pr.headSha)
+			?.author ?? null
+	);
+}
+
+const OPEN_QUESTIONS = /^##\s+Open questions\s*$[\s\S]*?(?=^##\s|(?![\s\S]))/im;
+
+/** The plan with its "## Open questions" section set to `questions`, last. */
+export function withOpenQuestions(plan: string, questions: string[]): string {
+	const rest = plan.replace(OPEN_QUESTIONS, "").trimEnd();
+	if (!questions.length) return rest;
+	return `${rest}\n\n## Open questions\n\n${questions.map((q) => `- ${q}`).join("\n")}`;
+}
+
+/** Bullets under the plan's "## Open questions". */
+export function openQuestions(plan: string | null): string[] {
+	const m = plan?.match(OPEN_QUESTIONS);
+	if (!m) return [];
+	return m[0]
+		.split("\n")
+		.slice(1)
+		.map((l) => l.match(/^\s*[-*]\s+(.+)$/)?.[1]?.trim())
+		.filter((q): q is string => Boolean(q));
+}
+
+/** Was the open-questions gate already posted for the latest plan? */
+function gatePosted(comments: Comment[]) {
+	for (let i = comments.length - 1; i >= 0; i--) {
+		const body = (comments[i] as Comment).body;
+		if (hasMarker(body, "questions")) return true;
+		if (hasMarker(body, "plan")) return false;
+	}
+	return false;
+}
+
 const fixCount = (pr: PR, kind: "ci" | "conflict") =>
 	pr.comments.reduce((n, c) => n + markerValues(c.body, kind).length, 0);
 
@@ -211,6 +259,16 @@ export function derive(snapshot: Snapshot, ctx: DeriveContext) {
 
 			case "ready":
 			case "inProgress": {
+				// Open questions keep a plan out of Ready. Once started, it runs on.
+				const questions =
+					item.column === "ready" && !issue.prs.length
+						? openQuestions(extractPlan(issue.body))
+						: [];
+				if (questions.length) {
+					if (!gatePosted(issue.comments))
+						actions.push({ kind: "openQuestions", item, questions });
+					break;
+				}
 				const n = exploreCount(issue.labels);
 				const variants =
 					n === null ? [null] : Array.from({ length: n }, (_, i) => i + 1);
@@ -263,6 +321,8 @@ export function derive(snapshot: Snapshot, ctx: DeriveContext) {
 					const job = prJob(item, pr, trusted, ctx, blocked);
 					if (job === "agentReviewed")
 						actions.push({ kind: "agentReviewed", item, pr });
+					else if (typeof job === "object" && job && "mergeBy" in job)
+						actions.push({ kind: "merge", item, pr, by: job.mergeBy });
 					else if (job === "ciExhausted") {
 						actions.push({
 							kind: "needsHuman",
@@ -299,7 +359,13 @@ function prJob(
 	trusted: ReadonlySet<string>,
 	ctx: DeriveContext,
 	blocked: (issue: Issue, key: string) => boolean,
-): Job | "agentReviewed" | "ciExhausted" | "conflictExhausted" | null {
+):
+	| Job
+	| { mergeBy: string }
+	| "agentReviewed"
+	| "ciExhausted"
+	| "conflictExhausted"
+	| null {
 	const { issue } = item;
 	const prKey = `#${issue.number}:pr${pr.number}`;
 	// One job per PR at a time, whatever its kind.
@@ -393,6 +459,18 @@ function prJob(
 	}
 
 	if (!pr.labels.includes(LABELS.agentReviewed)) return "agentReviewed";
+
+	// 6. Approved by a human: merge. Only kanbot's own PRs, never kanbot-review ones.
+	if (
+		ctx.config.merge.onApproval &&
+		pr.headRefName.startsWith("kanbot/") &&
+		!issue.labels.includes(LABELS.needsHuman) &&
+		pr.mergeable === "MERGEABLE" &&
+		(pr.checks === "SUCCESS" || pr.checks === null)
+	) {
+		const by = approvedBy(pr, trusted);
+		if (by) return { mergeBy: by };
+	}
 	return null;
 }
 

package/src/daemon/loop.ts

@@ -2,6 +2,8 @@ import { loadAgents } from "../agents/load.ts";
 import { sync } from "../agents/sync.ts";
 import { type Config, loadConfig } from "../config.ts";
 import { UserError } from "../errors.ts";
+import { viewer } from "../github/api.ts";
+import { botClient } from "../github/app.ts";
 import { Gh } from "../github/gh.ts";
 import { loadBoard, missingColumns } from "../github/project.ts";
 import { Trust } from "../github/trust.ts";
@@ -54,10 +56,13 @@ export async function runDaemon(root: string, opts: RunOptions) {
 
 	const release = opts.dryRun ? () => {} : await acquireLock(root);
 	const state = await new State(root).load();
+	const bot = botClient(config, gh);
 	const deps: JobDeps = {
 		root,
 		config,
 		gh,
+		bot,
+		me: await viewer(gh),
 		board,
 		agents,
 		provider: providerFor(config),
@@ -82,7 +87,7 @@ export async function runDaemon(root: string, opts: RunOptions) {
 	process.on("SIGTERM", stop);
 
 	log.info(
-		`kanbot: ${config.repo} · ${board.url} · provider ${config.provider} · ${config.concurrency} workers${opts.dryRun ? " · DRY RUN" : ""}`,
+		`kanbot: ${config.repo} · ${board.url} · provider ${config.provider} · ${config.concurrency} workers · talks as ${config.identity.mode === "app" ? `${config.identity.app?.slug}[bot]` : deps.me}${opts.dryRun ? " · DRY RUN" : ""}`,
 	);
 
 	try {
@@ -200,10 +205,14 @@ function describeAction(a: Action) {
 			return `label #${a.number} +[${a.add}] -[${a.remove}]`;
 		case "agentReviewed":
 			return `mark PR #${a.pr.number} agent-reviewed`;
+		case "merge":
+			return `merge PR #${a.pr.number}, approved by ${a.by}`;
 		case "compare":
 			return `post comparison on #${a.item.issue.number}`;
 		case "needsHuman":
 			return `needs-human #${a.number}`;
+		case "openQuestions":
+			return `open questions on #${a.item.issue.number}`;
 		case "resetFailures":
 			return `reset failures ${a.prefix}`;
 		case "cleanup":

package/src/daemon/snapshot.ts

@@ -63,6 +63,7 @@ export async function takeSnapshot(
 		...issue.prs.flatMap((p) => [
 			...p.comments.map((c) => c.author),
 			...p.reviews.map((c) => c.author),
+			...p.verdicts.map((v) => v.author),
 			...p.threads.flatMap((t) => t.comments.map((c) => c.author)),
 		]),
 	]);

package/src/daemon/types.ts

@@ -24,6 +24,21 @@ export type Checks =
 	| "EXPECTED"
 	| null;
 
+export type ReviewState =
+	| "APPROVED"
+	| "CHANGES_REQUESTED"
+	| "COMMENTED"
+	| "DISMISSED"
+	| "PENDING";
+
+/** A reviewer's latest review on a PR, body or not. */
+export type ReviewVerdict = {
+	author: string;
+	state: ReviewState;
+	/** Head commit the review was made on. */
+	commit: string | null;
+};
+
 export type PR = {
 	id: string;
 	number: number;
@@ -38,6 +53,8 @@ export type PR = {
 	comments: Comment[];
 	/** Submitted reviews that have a body. */
 	reviews: Comment[];
+	/** Latest review per reviewer, for approvals. */
+	verdicts: ReviewVerdict[];
 	threads: ReviewThread[];
 	checks: Checks;
 	/** UNKNOWN while GitHub is still computing it. */

package/src/github/api.ts

@@ -8,6 +8,7 @@ const PR_FIELDS = `
 	labels(first: 30) { nodes { name } }
 	comments(last: 100) { nodes { ${COMMENT} } }
 	reviews(last: 50) { nodes { ${COMMENT} } }
+	latestReviews(last: 20) { nodes { author { login } state commit { oid } } }
 	reviewThreads(last: 100) {
 		nodes {
 			id isResolved path line
@@ -103,6 +104,12 @@ function mapPR(p: any): PR {
 		comments: p.comments.nodes.map(comment),
 		reviews: p.reviews.nodes.map(comment).filter((r: Comment) => r.body.trim()),
 		// biome-ignore lint/suspicious/noExplicitAny: raw GraphQL shape
+		verdicts: p.latestReviews.nodes.map((r: any) => ({
+			author: r.author?.login ?? "ghost",
+			state: r.state,
+			commit: r.commit?.oid ?? null,
+		})),
+		// biome-ignore lint/suspicious/noExplicitAny: raw GraphQL shape
 		threads: p.reviewThreads.nodes.map((t: any) => ({
 			id: t.id,
 			isResolved: t.isResolved,
@@ -118,12 +125,21 @@ function mapPR(p: any): PR {
 
 // ---- writes ---------------------------------------------------------------
 
+/**
+ * Visible sign on kanbot's comments when it posts as the user. In app mode
+ * GitHub's bot badge already says so.
+ */
+export const SIGNATURE = "<sub>🤖 kanbot</sub>";
+
+export const signed = (gh: Gh, body: string) =>
+	gh.isBot ? body : `${SIGNATURE}\n\n${body}`;
+
 export function postComment(gh: Gh, number: number, body: string) {
 	return gh.restWrite(
 		`comment on #${number}`,
 		"POST",
 		gh.r(`/issues/${number}/comments`),
-		{ body },
+		{ body: signed(gh, body) },
 	);
 }
 
@@ -216,6 +232,35 @@ export function updatePRBody(gh: Gh, number: number, body: string) {
 	);
 }
 
+/** Merge only if the head is still `sha`, so later pushes aren't merged unseen. */
+export function mergePR(
+	gh: Gh,
+	number: number,
+	sha: string,
+	method: "squash" | "merge" | "rebase",
+) {
+	return gh.restWrite(
+		`merge PR #${number} (${method})`,
+		"PUT",
+		gh.r(`/pulls/${number}/merge`),
+		{ sha, merge_method: method },
+	);
+}
+
+export function requestReview(gh: Gh, number: number, logins: string[]) {
+	return gh.restWrite(
+		`request review on #${number} from ${logins.join(",")}`,
+		"POST",
+		gh.r(`/pulls/${number}/requested_reviewers`),
+		{ reviewers: logins },
+	);
+}
+
+/** Login of the account `gh` is signed in as. */
+export async function viewer(gh: Gh) {
+	return (await gh.rest<{ login: string }>("user")).login;
+}
+
 export function closePR(gh: Gh, number: number) {
 	return gh.restWrite(
 		`close PR #${number}`,
@@ -231,7 +276,7 @@ export function replyToThread(gh: Gh, threadId: string, body: string) {
 		`mutation($t: ID!, $b: String!) {
 			addPullRequestReviewThreadReply(input: { pullRequestReviewThreadId: $t, body: $b }) { comment { id } }
 		}`,
-		{ t: threadId, b: body },
+		{ t: threadId, b: signed(gh, body) },
 	);
 }