kanbot 0.2.0 → 0.4.0

package/README.md

@@ -26,10 +26,12 @@ Full docs: [docs/](./docs/00-index.md). Demo video: [docs/assets/demo.mp4](./doc
 | **Ready**       | Moving a card here approves the plan. Cards are picked top-down.                                                                                 |
 | **In Progress** | An agent implements it in its own worktree and opens a PR.                                                                                       |
 | **Review**      | Two agent reviews, with fixes. Then you're notified. Comment on the PR and an agent addresses it. CI failures and merge conflicts are fixed too. |
-| **Done**        | You merge.                                                                                                                                       |
+| **Done**        | You merge, or approve and kanbot merges ([`merge.onApproval`](./docs/12-identity.md#merge-on-approval)).                                         |
 
 A Bun daemon polls the board and runs one `claude -p` / `codex exec` process per job. GitHub is the only state, so you can restart it any time. Agents never get a GitHub token; the daemon makes every comment, push and PR. Only collaborators with write access can steer agents.
 
+kanbot talks as you by default. Run `kanbot app create` to have it talk as its own bot instead, so you can tell its messages apart and approve its PRs. Commits stay yours. With `merge.onApproval`, approving a PR merges it. [More](./docs/12-identity.md)
+
 ## Setup
 
 Requires [Bun](https://bun.sh) ≥ 1.3, `gh` logged in, and `claude` or `codex` logged in.
@@ -46,16 +48,17 @@ kanbot run
 
 Use `kanbot run --once --dry-run` to see what it would do. Run one daemon per repo.
 
+For a guided setup, run `bunx kanbot skills install` and ask your agent "help me set up kanbot".
+
 ## Labels
 
-| Label                                 | Meaning                                           |
-| ------------------------------------- | ------------------------------------------------- |
-| `technical`                           | Plan as a technical goal, not a user story        |
-| `type:frontend\|backend\|docs\|infra` | Picks the implementer agent (the planner sets it) |
-| `explore:2..4`                        | Build N alternative approaches as N PRs           |
-| `agent-reviewed`                      | Passed agent review; ready for you                |
-| `needs-human`                         | Agents gave up. Remove it to retry.               |
-| `kanbot-review`                       | Agent review for your own PR, without a card      |
+| Label            | Meaning                                      |
+| ---------------- | -------------------------------------------- |
+| `technical`      | Plan as a technical goal, not a user story   |
+| `explore:2..4`   | Build N alternative approaches as N PRs      |
+| `agent-reviewed` | Passed agent review; ready for you           |
+| `needs-human`    | Agents gave up. Remove it to retry.          |
+| `kanbot-review`  | Agent review for your own PR, without a card |
 
 ## Beyond the board
 
@@ -69,6 +72,7 @@ Use `kanbot run --once --dry-run` to see what it would do. Run one daemon per re
 - `.kanbot/config.yml`: concurrency, timeouts, notifications, column names.
 - `.kanbot/agents/*.md`: agent definitions. Run `kanbot sync` after editing; don't edit the generated `.claude/` or `.codex/` files.
 - `.agents/skills/`: skills shared by agents. Fill in `project-conventions` first.
+- `capabilities` in config: your own skills and agents for building, testing and reviewing. [More](./docs/13-capabilities.md)
 
 ## Upgrading
 
@@ -110,4 +114,6 @@ Commits follow [Conventional Commits](https://www.conventionalcommits.org). A `c
 2. A draft release updates with the next version and notes. `feat` bumps minor, `fix` patch. On 0.x, breaking changes bump minor.
 3. Publish the draft on GitHub. This tags the commit, publishes to npm with provenance, and commits the version to `package.json` on `main`.
 
+Docs: [kanbot.mib.im](https://kanbot.mib.im) shows the latest release, [kanbot.mib.im/main](https://kanbot.mib.im/main/) shows `main`. Both deploy on every push to `main` and on each release. `pnpm docs:dev` serves your working tree.
+
 Preview the next release with `pnpm release:preview`. Mark the draft as a pre-release to publish under the `next` tag.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "kanbot",
-	"version": "0.2.0",
+	"version": "0.4.0",
 	"description": "Run an autonomous dev team (Claude Code or Codex) from a GitHub Project board",
 	"type": "module",
 	"license": "MIT",

package/schema/config.schema.json

@@ -126,14 +126,7 @@
 			}
 		},
 		"implementers": {
-			"default": {
-				"frontend": "implementer-frontend",
-				"backend": "implementer-backend",
-				"docs": "implementer-docs",
-				"infra": "implementer-technical",
-				"default": "implementer-backend"
-			},
-			"description": "Maps a type:<key> label to an agent. `default` is the fallback.",
+			"description": "Deprecated: implement always uses `implementer`. While set, maps a type:<key> label to an agent, with `default` as the fallback. Use capabilities instead.",
 			"type": "object",
 			"propertyNames": {
 				"type": "string"
@@ -142,6 +135,43 @@
 				"type": "string"
 			}
 		},
+		"capabilities": {
+			"description": "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.",
+			"type": "object",
+			"propertyNames": {
+				"type": "string",
+				"pattern": "^[a-z][a-z0-9-]*$"
+			},
+			"additionalProperties": {
+				"anyOf": [
+					{
+						"type": "string",
+						"minLength": 1,
+						"description": "Skill or agent name, short for `{ use: <name> }`."
+					},
+					{
+						"type": "object",
+						"properties": {
+							"use": {
+								"type": "string",
+								"minLength": 1,
+								"description": "Skill in .agents/skills or agent in .kanbot/agents that does the work."
+							},
+							"when": {
+								"description": "When it applies, e.g. `Changes to UI users see`.",
+								"type": "string"
+							},
+							"required": {
+								"default": false,
+								"description": "A miss when it applies blocks acceptance review.",
+								"type": "boolean"
+							}
+						},
+						"required": ["use"]
+					}
+				]
+			}
+		},
 		"review": {
 			"default": {},
 			"type": "object",
@@ -165,6 +195,60 @@
 				}
 			}
 		},
+		"identity": {
+			"default": {},
+			"type": "object",
+			"properties": {
+				"mode": {
+					"default": "user",
+					"description": "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.",
+					"type": "string",
+					"enum": ["user", "app"]
+				},
+				"app": {
+					"default": null,
+					"description": "Set by `kanbot app create`. The private key lives in ~/.kanbot/apps/<id>.pem.",
+					"anyOf": [
+						{
+							"type": "object",
+							"properties": {
+								"id": {
+									"type": "integer",
+									"minimum": -9007199254740991,
+									"maximum": 9007199254740991,
+									"description": "GitHub App ID."
+								},
+								"slug": {
+									"type": "string",
+									"description": "App slug, as in github.com/apps/<slug>."
+								}
+							},
+							"required": ["id", "slug"]
+						},
+						{
+							"type": "null"
+						}
+					]
+				}
+			}
+		},
+		"merge": {
+			"default": {},
+			"type": "object",
+			"properties": {
+				"onApproval": {
+					"default": false,
+					"description": "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.",
+					"type": "boolean"
+				},
+				"method": {
+					"default": "squash",
+					"description": "Merge method used for approved PRs.",
+					"type": "string",
+					"enum": ["squash", "merge", "rebase"]
+				}
+			}
+		},
 		"codex": {
 			"default": {},
 			"type": "object",

package/src/agents/load.ts

@@ -63,6 +63,17 @@ export async function loadAgents(root: string): Promise<AgentDef[]> {
 	return agents;
 }
 
+/** `agent: skill` for each skill an agent lists that has no .agents/skills/<skill>/SKILL.md. */
+export function missingSkills(root: string, agents: AgentDef[]): string[] {
+	return agents.flatMap((a) =>
+		a.skills
+			.filter(
+				(s) => !existsSync(join(root, ".agents", "skills", s, "SKILL.md")),
+			)
+			.map((s) => `${a.name}: ${s}`),
+	);
+}
+
 function validate(agents: AgentDef[]) {
 	const names = new Set(agents.map((a) => a.name));
 	if (names.size !== agents.length) {

package/src/agents/sync.ts

@@ -42,7 +42,7 @@ export const CLAUDE_ATTRIBUTION = {
 export function claudeTools(agent: AgentDef): string[] {
 	const tools = agent.tools.flatMap((t) => CLAUDE_TOOLS[t] ?? []);
 	if (agent.skills.length) tools.push("Skill");
-	if (agent.subagents.length) tools.push("Task");
+	if (agent.subagents.length) tools.push("Agent");
 	return [...new Set(tools)];
 }
 
@@ -118,14 +118,14 @@ export type SyncFile = { path: string; content: string };
 const COPILOT_INSTRUCTIONS = join(".github", "copilot-instructions.md");
 
 /** Points Copilot code review at the same rules the kanbot reviewers use. */
-export const renderCopilotInstructions =
-	() => `<!-- generated by kanbot from review.copilot in .kanbot/config.yml -->
+export const renderCopilotInstructions = (review?: string) =>
+	`<!-- generated by kanbot from review.copilot in .kanbot/config.yml -->
 
 # Code review
 
 AI agents write most changes in this repo, from a plan in the linked issue. When you review a pull request:
 
-- Use the checklist and severity rubric in \`.agents/skills/code-review/SKILL.md\`.
+- Use the severity rubric and finding format in \`.agents/skills/review-findings/SKILL.md\`.${review ? `\n- Review the way the repo's \`review\` capability does: \`${review}\` in \`.agents/skills/\` or \`.kanbot/agents/\`.` : ""}
 - Check the change against the plan in the linked issue and the PR description.
 - Hold it to \`AGENTS.md\`, \`.agents/skills/project-conventions/SKILL.md\` and the facts in \`.agents/skills/project-memory/\`.
 - Comment on real problems: bugs, missing tests, security, broken conventions. Leave style to the linter.
@@ -155,12 +155,12 @@ export async function sync(
 	{ check = false } = {},
 ): Promise<string[]> {
 	const files = renderAll(agents);
-	const copilot =
-		existsSync(configPath(root)) && (await loadConfig(root)).review.copilot;
-	if (copilot)
+	const config = existsSync(configPath(root)) ? await loadConfig(root) : null;
+	const copilot = config?.review.copilot ?? false;
+	if (config && copilot)
 		files.push({
 			path: COPILOT_INSTRUCTIONS,
-			content: renderCopilotInstructions(),
+			content: renderCopilotInstructions(config.capabilities.review?.use),
 		});
 	const changed: string[] = [];
 	for (const f of files) {

package/src/capabilities.ts

@@ -0,0 +1,157 @@
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { AgentDef } from "./agents/load.ts";
+import type { Config, RESERVED_CAPABILITIES } from "./config.ts";
+import { TEMPLATES } from "./templates.ts";
+
+export type Capabilities = Config["capabilities"];
+
+/** Where a capability's `use` lives. `claude`/`codex` agents work on one provider only. */
+export type CapabilitySource = "skill" | "agent" | "claude" | "codex";
+
+export function findCapability(
+	root: string,
+	agents: AgentDef[],
+	use: string,
+): CapabilitySource | null {
+	if (existsSync(join(root, ".agents", "skills", use, "SKILL.md")))
+		return "skill";
+	if (agents.some((a) => a.name === use)) return "agent";
+	if (existsSync(join(root, ".claude", "agents", `${use}.md`))) return "claude";
+	if (existsSync(join(root, ".codex", "agents", `${use}.toml`))) return "codex";
+	return null;
+}
+
+/** Prompt section listing the repo's capabilities. Empty when none are mapped. */
+export function capabilitiesSection(caps: Capabilities, extra = ""): string {
+	const rows = Object.entries(caps);
+	if (!rows.length) return "";
+	const cell = (s: string) => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+	return [
+		"## Capabilities",
+		`The repo maps these needs to its own skills or agents. Use one when its "when" fits the task. Required ones must be used when they apply. For needs not listed, decide yourself.${extra ? ` ${extra}` : ""}`,
+		"",
+		"| Name | When | Use | Required |",
+		"| --- | --- | --- | --- |",
+		...rows.map(
+			([name, c]) =>
+				`| ${name} | ${cell(c.when ?? "When it fits the task")} | \`${c.use}\` | ${c.required ? "yes" : "no"} |`,
+		),
+	].join("\n");
+}
+
+/** Craft skills earlier kanbot versions installed, and the capability each maps to. */
+const LEGACY: [name: string, use: string, when?: string][] = [
+	["verify", "verify-ui", "Changes to UI users see"],
+	["review", "code-review"],
+	["tdd", "tdd", "Writing or changing behaviour"],
+	["ui-design", "frontend-design", "Building or restyling UI"],
+	["accessibility", "accessibility", "Changes to UI users see"],
+];
+
+/**
+ * A capabilities block for craft skills an earlier kanbot installed, so
+ * upgrades keep using them. Null when config already maps capabilities or
+ * none of them are present.
+ */
+export function legacyCapabilities(
+	root: string,
+	current: Capabilities,
+): Capabilities | null {
+	if (Object.keys(current).length) return null;
+	const found = LEGACY.filter(([, use]) =>
+		existsSync(join(root, ".agents", "skills", use, "SKILL.md")),
+	);
+	if (!found.length) return null;
+	return Object.fromEntries(
+		found.map(([name, use, when]) => [
+			name,
+			{ use, ...(when ? { when } : {}), required: false },
+		]),
+	);
+}
+
+export const RESERVED: Record<(typeof RESERVED_CAPABILITIES)[number], string> =
+	{
+		verify: "prove acceptance criteria",
+		review: "technical review",
+		preview: "something a human can try",
+	};
+
+/** Skills and agents in the repo that kanbot didn't ship. */
+export async function ownWorkers(root: string): Promise<string[]> {
+	const list = async (dir: string, ext?: string) =>
+		existsSync(dir)
+			? (await readdir(dir, { withFileTypes: true }))
+					.filter((e) => (ext ? e.name.endsWith(ext) : e.isDirectory()))
+					.map((e) => (ext ? e.name.slice(0, -ext.length) : e.name))
+			: [];
+	const shipped = new Set([
+		...(await list(join(TEMPLATES, ".agents", "skills"))),
+		...(await list(join(TEMPLATES, ".kanbot", "agents"), ".md")),
+	]);
+	const all = [
+		...(await list(join(root, ".agents", "skills"))),
+		...(await list(join(root, ".kanbot", "agents"), ".md")),
+	];
+	return [...new Set(all)].filter((n) => !shipped.has(n)).sort();
+}
+
+/**
+ * Asks which of the repo's own skills or agents fill each reserved need.
+ * `ask` returns the answer, or null/empty to skip.
+ */
+export function askCapabilities(
+	workers: string[],
+	ask: (question: string) => string | null,
+	say: (line: string) => void = console.log,
+): Capabilities {
+	const caps: Capabilities = {};
+	if (!workers.length) return caps;
+	say(
+		`Your skills and agents:\n${workers.map((w, i) => `  ${i + 1}. ${w}`).join("\n")}`,
+	);
+	const yes = ask("Map them to kanbot capabilities now? [y/N]");
+	if (!/^y/i.test(yes?.trim() ?? "")) return caps;
+	for (const [name, what] of Object.entries(RESERVED)) {
+		const answer = ask(
+			`${name} (${what}): number or name, Enter to skip`,
+		)?.trim();
+		if (!answer) continue;
+		const use = workers[Number(answer) - 1] ?? answer;
+		if (workers.includes(use)) caps[name] = { use, required: false };
+		else say(`  "${answer}" not found, skipped ${name}.`);
+	}
+	return caps;
+}
+
+/** One line: what is mapped, and which reserved needs aren't. */
+export function capabilitySummary(caps: Capabilities): string {
+	const mapped = Object.entries(caps).map(([n, c]) => `${n} → ${c.use}`);
+	const missing = Object.keys(RESERVED).filter((n) => !caps[n]);
+	return [
+		mapped.join(", ") || "none mapped",
+		missing.length
+			? `could add ${missing.join(", ")} (kanbot-guide can help)`
+			: "",
+	]
+		.filter(Boolean)
+		.join("; ");
+}
+
+/** Capabilities as written to config: a bare name when that says it all. */
+export function compact(caps: Capabilities) {
+	return Object.fromEntries(
+		Object.entries(caps).map(([name, c]) => [
+			name,
+			!c.when && !c.required
+				? c.use
+				: {
+						use: c.use,
+						...(c.when ? { when: c.when } : {}),
+						...(c.required ? { required: true } : {}),
+					},
+		]),
+	);
+}

package/src/commands/app.ts

@@ -0,0 +1,169 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { chmod, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { defineCommand } from "citty";
+import { loadConfig, saveConfig } from "../config.ts";
+import { UserError } from "../errors.ts";
+import { appKeyPath, appManifest, convertManifest } from "../github/app.ts";
+import { Gh } from "../github/gh.ts";
+import { log } from "../log.ts";
+
+const WAIT_MS = 10 * 60_000;
+
+function openBrowser(url: string) {
+	const cmd =
+		process.platform === "darwin"
+			? "open"
+			: process.platform === "win32"
+				? "explorer"
+				: "xdg-open";
+	try {
+		Bun.spawn([cmd, url], { stdout: "ignore", stderr: "ignore" });
+	} catch {}
+}
+
+const escAttr = (s: string) => s.replace(/&/g, "&").replace(/"/g, """);
+
+/** A page that posts the manifest to GitHub, as the manifest flow requires. */
+function formPage(action: string, manifest: unknown) {
+	return `<!doctype html><meta charset="utf-8"><title>kanbot app</title>
+<form id="f" method="post" action="${escAttr(action)}">
+<input type="hidden" name="manifest" value="${escAttr(JSON.stringify(manifest))}">
+<button>Create the kanbot app on GitHub</button></form>
+<script>document.getElementById("f").submit()</script>`;
+}
+
+const page = (msg: string) =>
+	new Response(
+		`<!doctype html><meta charset="utf-8"><title>kanbot app</title><p>${msg}</p>`,
+		{ headers: { "content-type": "text/html" } },
+	);
+
+const create = defineCommand({
+	meta: {
+		name: "create",
+		description:
+			"Create a GitHub App for kanbot to talk as, and switch to app mode",
+	},
+	args: {
+		name: {
+			type: "string",
+			description: "App name, unique on GitHub (default: kanbot-<owner>)",
+		},
+	},
+	async run({ args }) {
+		const root = process.cwd();
+		const config = await loadConfig(root);
+		const gh = new Gh(config.repo);
+		const owner = gh.owner;
+		const { type } = await gh.rest<{ type: string }>(`users/${owner}`);
+		const name = (args.name ?? `kanbot-${owner}`).slice(0, 34);
+		const state = randomUUID();
+		const action =
+			type === "Organization"
+				? `https://github.com/organizations/${owner}/settings/apps/new?state=${state}`
+				: `https://github.com/settings/apps/new?state=${state}`;
+
+		const got = Promise.withResolvers<string>();
+		const server = Bun.serve({
+			port: 0,
+			hostname: "localhost",
+			fetch(req): Response {
+				const url = new URL(req.url);
+				if (url.pathname === "/")
+					return new Response(
+						formPage(
+							action,
+							appManifest(name, `http://localhost:${url.port}/callback`),
+						),
+						{ headers: { "content-type": "text/html" } },
+					);
+				if (url.pathname !== "/callback")
+					return new Response("", { status: 404 });
+				const code = url.searchParams.get("code");
+				if (url.searchParams.get("state") !== state || !code)
+					return page("Unexpected request. Run `kanbot app create` again.");
+				got.resolve(code);
+				return page("App created. Go back to your terminal.");
+			},
+		});
+		const start = `http://localhost:${server.port}/`;
+		log.info(`Opening ${start} — confirm the app on GitHub.`);
+		openBrowser(start);
+		const timer = setTimeout(
+			() => got.reject(new Error("timed out waiting for GitHub")),
+			WAIT_MS,
+		);
+		let code: string;
+		try {
+			code = await got.promise;
+		} catch (e) {
+			throw new UserError("No app was created.", {
+				why: String(e),
+				fix: "kanbot app create",
+				docs: "identity#app-mode",
+			});
+		} finally {
+			clearTimeout(timer);
+			server.stop();
+		}
+
+		const app = await convertManifest(code);
+		const keyFile = appKeyPath(app.id);
+		await mkdir(dirname(keyFile), { recursive: true });
+		await Bun.write(keyFile, app.pem);
+		await chmod(keyFile, 0o600);
+		await saveConfig(root, {
+			identity: { mode: "app", app: { id: app.id, slug: app.slug } },
+		});
+		const install = `https://github.com/apps/${app.slug}/installations/new`;
+		log.info(`Created ${app.slug} (id ${app.id}). Key: ${keyFile}`);
+		log.info(`Now install it on ${config.repo}: ${install}`);
+		openBrowser(install);
+		console.log(
+			"\nThen commit .kanbot/config.yml, run `kanbot doctor` and restart the daemon.",
+		);
+	},
+});
+
+const link = defineCommand({
+	meta: {
+		name: "link",
+		description: "Use a kanbot app you already created, e.g. for another repo",
+	},
+	args: {
+		id: { type: "string", required: true, description: "GitHub App ID" },
+		slug: {
+			type: "string",
+			required: true,
+			description: "App slug, as in github.com/apps/<slug>",
+		},
+	},
+	async run({ args }) {
+		const root = process.cwd();
+		const id = Number(args.id);
+		if (!Number.isInteger(id))
+			throw new UserError("--id must be a number.", {
+				docs: "identity#use-the-app-in-another-repo",
+			});
+		await saveConfig(root, {
+			identity: { mode: "app", app: { id, slug: args.slug } },
+		});
+		const config = await loadConfig(root);
+		log.info(`kanbot talks as ${args.slug}[bot] in ${config.repo}.`);
+		if (!existsSync(appKeyPath(id)))
+			log.warn(`No private key at ${appKeyPath(id)}. Copy it there.`);
+		log.info(
+			`Install it on the repo if needed: https://github.com/apps/${args.slug}/installations/new`,
+		);
+	},
+});
+
+export default defineCommand({
+	meta: {
+		name: "app",
+		description: "Manage the GitHub App kanbot talks as",
+	},
+	subCommands: { create, link },
+});

package/src/commands/board.ts

@@ -1,5 +1,6 @@
 import { defineCommand } from "citty";
 import { LABELS, loadConfig, saveConfig } from "../config.ts";
+import { UserError } from "../errors.ts";
 import { ensureCopilotRuleset, ensureLabel } from "../github/api.ts";
 import { Gh } from "../github/gh.ts";
 import { createBoard, loadBoard, missingColumns } from "../github/project.ts";
@@ -12,10 +13,6 @@ export const REPO_LABELS: [name: string, color: string, description: string][] =
 			"5319e7",
 			"Technical work; planned as a technical goal instead of a user story",
 		],
-		["type:frontend", "1d76db", "User-facing UI work"],
-		["type:backend", "0e8a16", "Server, data or API work"],
-		["type:docs", "c5def5", "Documentation"],
-		["type:infra", "bfd4f2", "Tooling, CI, infrastructure"],
 		[
 			"explore:2",
 			"fbca04",
@@ -62,7 +59,7 @@ const create = defineCommand({
 	meta: {
 		name: "create",
 		description:
-			"Create a GitHub Project board for this repo with the kanbot columns",
+			"Create a GitHub Project board for this repo with the kanbot columns and labels",
 	},
 	args: {
 		title: {
@@ -109,7 +106,11 @@ ${board.url}`);
 });
 
 const link = defineCommand({
-	meta: { name: "link", description: "Use an existing project board" },
+	meta: {
+		name: "link",
+		description:
+			"Use an existing project board, e.g. github.com/users/<owner>/projects/<number>",
+	},
 	args: {
 		owner: {
 			type: "string",
@@ -120,8 +121,14 @@ const link = defineCommand({
 	},
 	async run({ args }) {
 		const root = process.cwd();
+		const number = Number(args.number);
+		if (!Number.isInteger(number))
+			throw new UserError("--number must be a number.", {
+				why: "It's the number at the end of the project URL.",
+				docs: "getting-started#create-the-board",
+			});
 		await saveConfig(root, {
-			project: { owner: args.owner, number: Number(args.number) },
+			project: { owner: args.owner, number },
 		});
 		const config = await loadConfig(root);
 		const board = await loadBoard(new Gh(config.repo), config);