kanbot 0.1.0 → 0.3.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,6 +48,8 @@ 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                                           |
@@ -101,3 +105,15 @@ bun test
 pnpm check
 pnpm typecheck
 ```
+
+Commits follow [Conventional Commits](https://www.conventionalcommits.org). A `commit-msg` hook and CI lint them.
+
+### Releasing
+
+1. Merge or push conventional commits to `main`.
+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.1.0",
+	"version": "0.3.0",
 	"description": "Run an autonomous dev team (Claude Code or Codex) from a GitHub Project board",
 	"type": "module",
 	"license": "MIT",
@@ -41,7 +41,9 @@
 		"docs:dev": "pnpm --dir site dev",
 		"docs:build": "pnpm --dir site build",
 		"hashes": "bun scripts/known-hashes.ts",
-		"prepublishOnly": "bun run check && bun run typecheck && bun test"
+		"prepublishOnly": "bun run check && bun run typecheck && bun test",
+		"prepare": "lefthook install",
+		"release:preview": "git-cliff --unreleased --bump --strip all && git-cliff --bumped-version"
 	},
 	"dependencies": {
 		"citty": "^0.2.2",
@@ -51,7 +53,24 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.6.4",
+		"@commitlint/cli": "^21.2.4",
+		"@commitlint/config-conventional": "^21.2.4",
 		"@types/bun": "^1.4.4",
+		"git-cliff": "^2.14.2",
+		"lefthook": "^2.2.2",
 		"typescript": "^7.0.2"
+	},
+	"commitlint": {
+		"extends": [
+			"@commitlint/config-conventional"
+		],
+		"rules": {
+			"body-max-line-length": [
+				0
+			],
+			"footer-max-line-length": [
+				0
+			]
+		}
 	}
 }

package/schema/config.schema.json

@@ -165,6 +165,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

@@ -1,7 +1,9 @@
+import { existsSync } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { parse } from "yaml";
 import { z } from "zod";
+import { UserError } from "../errors.ts";
 import { RESULT_SCHEMAS } from "../schemas/results.ts";
 
 export const TOOL_CAPABILITIES = ["read", "edit", "bash", "web"] as const;
@@ -34,16 +36,23 @@ export function agentsDir(root: string) {
 
 export function parseAgent(text: string, file: string): AgentDef {
 	const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
-	if (!m) throw new Error(`${file}: missing YAML frontmatter`);
+	if (!m) throw invalid(file, "Missing YAML frontmatter between `---` lines.");
 	const fm = Frontmatter.safeParse(parse(m[1] as string));
 	if (!fm.success) {
-		throw new Error(`${file}: ${z.prettifyError(fm.error)}`);
+		throw invalid(file, z.prettifyError(fm.error));
 	}
 	return { ...fm.data, body: (m[2] as string).trim(), file };
 }
 
 export async function loadAgents(root: string): Promise<AgentDef[]> {
 	const dir = agentsDir(root);
+	if (!existsSync(dir)) {
+		throw new UserError("kanbot agents are missing.", {
+			why: "No .kanbot/agents directory in this repo.",
+			fix: "kanbot init (or kanbot upgrade to restore missing files)",
+			docs: "getting-started#set-up-a-repository",
+		});
+	}
 	const files = (await readdir(dir)).filter((f) => f.endsWith(".md")).sort();
 	const agents = await Promise.all(
 		files.map(async (f) =>
@@ -57,25 +66,38 @@ export async function loadAgents(root: string): Promise<AgentDef[]> {
 function validate(agents: AgentDef[]) {
 	const names = new Set(agents.map((a) => a.name));
 	if (names.size !== agents.length) {
-		throw new Error("Duplicate agent names in .kanbot/agents");
+		throw new UserError("Duplicate agent names in .kanbot/agents.", {
+			why: "Two agent files declare the same `name`.",
+			fix: "Give each agent a unique name matching its filename.",
+			docs: "agents#frontmatter",
+		});
 	}
 	for (const a of agents) {
 		if (!a.file.endsWith(`${a.name}.md`)) {
-			throw new Error(`${a.file}: name "${a.name}" must match the filename`);
+			throw invalid(a.file, `name "${a.name}" must match the filename.`);
 		}
 		if (a.tier === "column" && !a.output) {
-			throw new Error(`${a.file}: column agents must declare an output schema`);
+			throw invalid(a.file, "Column agents must declare an `output` schema.");
 		}
 		for (const s of a.subagents) {
 			const sub = agents.find((x) => x.name === s);
-			if (!sub) throw new Error(`${a.file}: unknown subagent "${s}"`);
+			if (!sub)
+				throw invalid(a.file, `Unknown subagent "${s}" in \`subagents\`.`);
 			if (sub.tier !== "sub") {
-				throw new Error(`${a.file}: "${s}" is not a tier: sub agent`);
+				throw invalid(a.file, `Subagent "${s}" must have \`tier: sub\`.`);
 			}
 		}
 	}
 }
 
+function invalid(file: string, why: string) {
+	return new UserError(`Invalid agent file ${file}`, {
+		why,
+		fix: "Fix the file, then run `kanbot sync`.",
+		docs: "agents#frontmatter",
+	});
+}
+
 export function getAgent(agents: AgentDef[], name: string): AgentDef {
 	const a = agents.find((x) => x.name === name);
 	if (!a) throw new Error(`No agent named "${name}" in .kanbot/agents`);

package/src/agents/sync.ts

@@ -3,6 +3,7 @@ import { mkdir, readdir, rm, symlink } from "node:fs/promises";
 import { join } from "node:path";
 import { stringify } from "yaml";
 import { configPath, loadConfig } from "../config.ts";
+import { UserError } from "../errors.ts";
 import type { AgentDef } from "./load.ts";
 
 /*
@@ -205,9 +206,11 @@ async function linkSkills(root: string, check: boolean) {
 	const ok = existsSync(link) && lstatSync(link).isSymbolicLink();
 	if (ok || check) return ok;
 	if (existsSync(link)) {
-		throw new Error(
-			".claude/skills exists and is not a symlink. Move its skills into .agents/skills.",
-		);
+		throw new UserError("Cannot link .claude/skills.", {
+			why: ".claude/skills exists and is not a symlink. kanbot keeps skills in .agents/skills and links to them.",
+			fix: "Move its skills into .agents/skills, delete .claude/skills, then rerun.",
+			docs: "skills#add-a-skill",
+		});
 	}
 	await mkdir(join(root, ".agents", "skills"), { recursive: true });
 	await mkdir(join(root, ".claude"), { recursive: true });

package/src/cli.ts

@@ -1,5 +1,27 @@
 #!/usr/bin/env bun
-import { runMain } from "citty";
+import { runCommand, runMain } from "citty";
+import { formatError } from "./errors.ts";
 import { main } from "./main.ts";
 
-runMain(main);
+const args = process.argv.slice(2);
+const usage =
+	!args.length ||
+	args.some((a) => a === "--help" || a === "-h") ||
+	(args.length === 1 && (args[0] === "--version" || args[0] === "-v"));
+
+// citty prints usage for help, version and a bare `kanbot`.
+if (usage) {
+	await runMain(main);
+} else {
+	try {
+		await runCommand(main, { rawArgs: args });
+	} catch (e) {
+		// Leading positionals name the command, e.g. "board create".
+		const end = args.findIndex((a) => a.startsWith("-"));
+		const command = args.slice(0, end < 0 ? undefined : end).join(" ");
+		console.error(
+			formatError(e, { debug: !!process.env.KANBOT_DEBUG, command }),
+		);
+		process.exit(1);
+	}
+}

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/completion.ts

@@ -1,6 +1,7 @@
 import { basename } from "node:path";
 import { defineCommand } from "citty";
 import { buildSpec, render, SHELLS, type Shell } from "../completion.ts";
+import { UserError } from "../errors.ts";
 
 export default defineCommand({
 	meta: {
@@ -17,7 +18,12 @@ export default defineCommand({
 	async run({ args }) {
 		const shell = args.shell ?? basename(process.env.SHELL ?? "");
 		if (!SHELLS.includes(shell as Shell))
-			throw new Error(`Pass --shell ${SHELLS.join("|")}`);
+			throw new UserError("Could not detect your shell.", {
+				why: `$SHELL is "${shell}", which is not supported.`,
+				fix: `kanbot completion --shell ${SHELLS.join("|")}`,
+				docs: "getting-started#shell-completion",
+				more: "",
+			});
 		const { main } = await import("../main.ts");
 		process.stdout.write(render(shell as Shell, await buildSpec(main)));
 	},

package/src/commands/doctor.ts

@@ -5,7 +5,9 @@ import { loadAgents } from "../agents/load.ts";
 import { sync } from "../agents/sync.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,
@@ -27,6 +29,16 @@ async function cmd(args: string[]) {
 	return { ok: code === 0, out: `${out}${err}`.trim() };
 }
 
+/** Failure detail and fix for a check, from a thrown error. */
+function explain(e: unknown, fallback?: string) {
+	const d = describeError(e);
+	const detail = [d.message, d.why].filter(Boolean).join("\n");
+	return {
+		detail: detail.replace(/\n/g, "\n    "),
+		fix: d.fix ?? fallback,
+	};
+}
+
 export default defineCommand({
 	meta: {
 		name: "doctor",
@@ -59,7 +71,7 @@ export default defineCommand({
 				detail: `${config.repo}, provider ${config.provider}`,
 			});
 		} catch (e) {
-			add({ name: "config", ok: false, detail: String(e), fix: "kanbot init" });
+			add({ name: "config", ok: false, ...explain(e, "kanbot init") });
 			return process.exit(1);
 		}
 
@@ -119,7 +131,7 @@ export default defineCommand({
 				fix: "kanbot sync",
 			});
 		} catch (e) {
-			add({ name: "agents", ok: false, detail: String(e) });
+			add({ name: "agents", ok: false, ...explain(e) });
 		}
 
 		const plan = await planUpgrade(root);
@@ -197,8 +209,7 @@ export default defineCommand({
 			add({
 				name: "project board",
 				ok: false,
-				detail: String(e),
-				fix: "kanbot board create",
+				...explain(e, "kanbot board create"),
 			});
 		}
 
@@ -226,6 +237,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

@@ -4,6 +4,7 @@ import { defineCommand } from "citty";
 import { loadAgents } from "../agents/load.ts";
 import { sync } from "../agents/sync.ts";
 import { configPath, saveConfig, writeConfigSchema } from "../config.ts";
+import { UserError } from "../errors.ts";
 import { run } from "../github/gh.ts";
 import { log } from "../log.ts";
 import { applyUpgrade, NEW_SUFFIX, planUpgrade } from "../templates.ts";
@@ -32,9 +33,31 @@ export default defineCommand({
 	async run({ args }) {
 		const root = process.cwd();
 		if (!existsSync(join(root, ".git")))
-			throw new Error("Run inside a git repository.");
+			throw new UserError("Not a git repository.", {
+				why: `No .git in ${root}. Run init from the repo root.`,
+				fix: "cd into your repo's root, or run `git init`.",
+				docs: "getting-started#set-up-a-repository",
+				more: "",
+			});
 		if (!["claude", "codex"].includes(args.provider))
-			throw new Error("--provider must be claude or codex");
+			throw new UserError(`Unknown provider "${args.provider}".`, {
+				fix: "kanbot init --provider claude|codex",
+				docs: "providers#choose-a-provider",
+				more: "",
+			});
+
+		// Fail on gh or remote problems before writing anything.
+		const repo =
+			!existsSync(configPath(root)) || args.force
+				? (JSON.parse(
+						await run([
+							"repo",
+							"view",
+							"--json",
+							"nameWithOwner,defaultBranchRef",
+						]),
+					) as { nameWithOwner: string; defaultBranchRef: { name: string } })
+				: null;
 
 		const plan = await planUpgrade(root, { force: args.force });
 		await applyUpgrade(root, plan);
@@ -47,13 +70,7 @@ export default defineCommand({
 		}
 		log.info("+ .kanbot/manifest.json");
 
-		if (!existsSync(configPath(root)) || args.force) {
-			const repo = JSON.parse(
-				await run(["repo", "view", "--json", "nameWithOwner,defaultBranchRef"]),
-			) as {
-				nameWithOwner: string;
-				defaultBranchRef: { name: string };
-			};
+		if (repo) {
 			await saveConfig(root, {
 				provider: args.provider as "claude" | "codex",
 				repo: repo.nameWithOwner,

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/status.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { defineCommand } from "citty";
 import { COLUMN_KEYS, LABELS, loadConfig } from "../config.ts";
 import { State } from "../daemon/state.ts";
-import { Gh } from "../github/gh.ts";
+import { Gh, run } from "../github/gh.ts";
 import { listItems, loadBoard } from "../github/project.ts";
 
 export default defineCommand({
@@ -38,7 +38,16 @@ export default defineCommand({
 		}
 
 		const needsHuman = JSON.parse(
-			await Bun.$`gh issue list --repo ${config.repo} --label ${LABELS.needsHuman} --json number,title`.text(),
+			await run([
+				"issue",
+				"list",
+				"--repo",
+				config.repo,
+				"--label",
+				LABELS.needsHuman,
+				"--json",
+				"number,title",
+			]),
 		) as { number: number; title: string }[];
 		if (needsHuman.length) {
 			console.log(