kanbot 0.5.1 → 0.6.0

package/src/commands/init.ts

@@ -3,27 +3,66 @@ import { join } from "node:path";
 import { defineCommand } from "citty";
 import { loadAgents } from "../agents/load.ts";
 import { sync } from "../agents/sync.ts";
+import { type Ask, confirm, openBrowser, type Say } from "../ask.ts";
 import { askCapabilities, compact, ownWorkers } from "../capabilities.ts";
-import { configPath, saveConfig, writeConfigSchema } from "../config.ts";
-import { DOCS_URL, UserError } from "../errors.ts";
+import { color } from "../color.ts";
+import {
+	type Config,
+	configPath,
+	loadConfig,
+	saveConfig,
+	writeConfigSchema,
+} from "../config.ts";
+import { DOCS_URL, describeError, UserError } from "../errors.ts";
 import { run } from "../github/gh.ts";
+import { workflowsUrl } from "../github/project.ts";
 import { log } from "../log.ts";
-import { applyUpgrade, NEW_SUFFIX, planUpgrade } from "../templates.ts";
+import { LOGIN_FIX, providerLogin } from "../providers/login.ts";
+import {
+	askBoard,
+	askIdentity,
+	askMerge,
+	askOptions,
+	askProvider,
+} from "../setup.ts";
+import {
+	applyUpgrade,
+	type Change,
+	NEW_SUFFIX,
+	planUpgrade,
+} from "../templates.ts";
+import { createApp } from "./app.ts";
+import {
+	linkBoard,
+	parseProjectUrl,
+	printWorkflows,
+	setupBoard,
+} from "./board.ts";
 
 const GITIGNORE = [".kanbot/state.json", ".kanbot/logs/", ".kanbot/daemon.pid"];
 
+const ask: Ask = (q) => prompt(q);
+const say: Say = (l) => console.log(l);
+const step = (title: string) =>
+	console.log(`\n${color.bold(color.cyan(title))}`);
+
 export default defineCommand({
 	meta: {
 		name: "init",
 		description:
-			"Scaffold kanbot agents, skills and GitHub files into this repo",
+			"Set up kanbot in this repo: pick a provider and options, add agents, skills and GitHub files, and create the board",
 	},
 	args: {
 		provider: {
 			type: "enum",
 			options: ["claude", "codex"],
-			description: "Agent provider",
-			default: "claude",
+			description:
+				"Agent provider (default: ask, or claude without a terminal)",
+		},
+		yes: {
+			type: "boolean",
+			description: "Don't ask; use defaults and set up the board later",
+			default: false,
 		},
 		force: {
 			type: "boolean",
@@ -40,49 +79,94 @@ export default defineCommand({
 				docs: "getting-started#set-up-a-repository",
 				more: "",
 			});
-		if (!["claude", "codex"].includes(args.provider))
+		if (args.provider && !["claude", "codex"].includes(args.provider))
 			throw new UserError(`Unknown provider "${args.provider}".`, {
 				fix: "kanbot init --provider claude|codex",
 				docs: "providers#choose-a-provider",
 				more: "",
 			});
+		// Only ask when someone can answer.
+		const interactive = !!process.stdin.isTTY && !args.yes;
+		const fresh = !existsSync(configPath(root)) || args.force;
 
 		// 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 repo = fresh
+			? (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);
-		for (const c of plan.changes) {
-			if (c.action === "add" || c.action === "update") log.info(`+ ${c.path}`);
-			if (c.action === "conflict")
-				log.warn(
-					`! ${c.path} exists; kanbot's version is in ${c.path}${NEW_SUFFIX}`,
-				);
+		if (interactive)
+			say(
+				`${color.bold("kanbot init")} ${color.dim(
+					repo
+						? `sets up ${repo.nameWithOwner}. Press Enter to take the default.`
+						: "updates files and asks about what isn't set up yet.",
+				)}`,
+			);
+
+		let provider = args.provider as Config["provider"] | undefined;
+		if (!provider && repo && interactive) {
+			step("Provider");
+			provider = askProvider(ask, say, {
+				claude: await providerLogin("claude"),
+				codex: await providerLogin("codex"),
+			});
 		}
-		log.info("+ .kanbot/manifest.json");
 
+		if (interactive) step("Files");
+		const plan = await planUpgrade(root, { force: args.force });
+		await applyUpgrade(root, plan);
+		printChanges(plan.changes);
 		if (repo) {
 			await saveConfig(root, {
-				provider: args.provider as "claude" | "codex",
+				provider: provider ?? "claude",
 				repo: repo.nameWithOwner,
 				baseBranch: repo.defaultBranchRef.name,
 			});
 			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);
+		}
+		await writeCodeowners(root);
+		await appendGitignore(root);
+		const changed = await sync(root, await loadAgents(root));
+		if (await writeConfigSchema(root))
+			changed.push(".kanbot/config.schema.json");
+		printGrouped(changed, "~", "generated");
+
+		const config = await loadConfig(root);
+		const login = await providerLogin(config.provider);
+		if (!login.ok)
+			log.warn(
+				`${config.provider} is ${login.installed ? "not logged in with a subscription" : "not installed"}. Run: ${LOGIN_FIX[config.provider]}`,
+			);
+
+		let workflowsShown = false;
+		if (interactive) {
+			if (repo) {
+				step("GitHub identity");
+				const identity = askIdentity(ask, say);
+				if (identity === "app")
+					await tryStep(() => createApp(root), "kanbot app create");
+				const merge = askMerge(ask, say, identity);
+				if (merge.onApproval)
+					await saveConfig(root, { merge: merge as Config["merge"] });
+
+				step("Options");
+				const options = askOptions(ask, say, config.provider);
+				if (Object.keys(options).length) await saveConfig(root, options);
+			}
+
+			const workers = await ownWorkers(root);
+			if (workers.length && !Object.keys(config.capabilities).length) {
+				step("Capabilities");
+				const caps = askCapabilities(workers, ask, say);
 				if (Object.keys(caps).length) {
 					await saveConfig(root, { capabilities: compact(caps) } as never);
 					log.info(
@@ -90,37 +174,143 @@ export default defineCommand({
 					);
 				}
 			}
-		}
 
-		const codeowners = join(root, ".github", "CODEOWNERS");
-		if (!existsSync(codeowners)) {
-			const login = (await run(["api", "user", "--jq", ".login"])).trim();
-			await Bun.write(
-				codeowners,
-				`# Human reviewers. kanbot acts as your account, so this documents ownership\n# rather than triggering review requests for your own PRs.\n* @${login}\n`,
-			);
-			log.info(`+ .github/CODEOWNERS (@${login})`);
+			if (!config.project) {
+				step("Board");
+				workflowsShown = await boardStep(root);
+			}
 		}
 
-		await appendGitignore(root);
-		const changed = await sync(root, await loadAgents(root));
-		if (await writeConfigSchema(root))
-			changed.push(".kanbot/config.schema.json");
-		for (const f of changed) log.info(`~ ${f} (generated)`);
-
-		console.log(`
-Next steps:
-  1. Review AGENTS.md and fill in .agents/skills/project-conventions/SKILL.md
-     (ask your agent to draft it; see ${DOCS_URL}/project-conventions)
-  2. Adjust .github/workflows/ci.yml to your stack (agents fix failing CI)
-  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 doctor              # checks auth, board, generated files
-  7. kanbot run                 # start the loop (or kanbot run --once --dry-run)`);
+		const { project } = await loadConfig(root);
+		const next = [
+			`Review AGENTS.md and fill in .agents/skills/project-conventions/SKILL.md
+     (ask your agent to draft it; see ${DOCS_URL}/project-conventions)`,
+			"Adjust .github/workflows/ci.yml to your stack (agents fix failing CI)",
+			...(interactive
+				? []
+				: [
+						"Map your own skills under capabilities in .kanbot/config.yml (kanbot-guide can help)",
+					]),
+			...(workflowsShown
+				? ["Turn on the board workflows listed above"]
+				: project
+					? []
+					: [
+							"kanbot board create        # board and labels; enable the workflows it prints",
+						]),
+			"Commit and push these files to the default branch (agents work from it)",
+			"kanbot doctor              # checks auth, board, generated files",
+			"kanbot run                 # start the loop (or kanbot run --once --dry-run)",
+		];
+		console.log(
+			`\n${color.bold("Next steps:")}\n${next.map((s, i) => `  ${i + 1}. ${s}`).join("\n")}`,
+		);
 	},
 });
 
+/** Lists what changed, one line per folder, and each conflict in full. */
+function printChanges(changes: Change[]) {
+	printGrouped(
+		changes
+			.filter((c) => c.action === "add" || c.action === "update")
+			.map((c) => c.path),
+		"+",
+	);
+	for (const c of changes)
+		if (c.action === "conflict")
+			log.warn(
+				`! ${c.path} exists; kanbot's version is in ${c.path}${NEW_SUFFIX}`,
+			);
+	log.info("+ .kanbot/manifest.json");
+}
+
+/** One line per folder two levels deep, e.g. `+ .agents/skills/ (13 files)`. */
+function printGrouped(paths: string[], mark: string, note = "") {
+	const groups = new Map<string, number>();
+	for (const path of paths) {
+		const parts = path.split("/");
+		const key = parts.length > 2 ? `${parts.slice(0, 2).join("/")}/` : path;
+		groups.set(key, (groups.get(key) ?? 0) + 1);
+	}
+	for (const [path, n] of groups) {
+		const notes = [n > 1 ? `${n} files` : "", note].filter(Boolean);
+		log.info(`${mark} ${path}${notes.length ? ` (${notes.join(", ")})` : ""}`);
+	}
+}
+
+/** Runs a step that may fail without stopping init. */
+async function tryStep(fn: () => Promise<unknown>, retry: string) {
+	try {
+		await fn();
+		return true;
+	} catch (e) {
+		const d = describeError(e);
+		log.warn(`${d.message}${d.fix ? ` Fix: ${d.fix}` : ""}`);
+		log.warn(`Skipped. Run \`${retry}\` later.`);
+		return false;
+	}
+}
+
+/** Asks how to get a board, then creates or links it. True if it printed the workflows to turn on. */
+async function boardStep(root: string) {
+	if (!/'project'/.test(await authStatus())) {
+		say("Your gh token needs the `project` scope to manage boards.");
+		if (!confirm(ask, "Run `gh auth refresh -s project` now?", true)) {
+			say("  Skipped. Run it, then `kanbot board create`.");
+			return false;
+		}
+		const p = Bun.spawn(["gh", "auth", "refresh", "-s", "project"], {
+			stdio: ["inherit", "inherit", "inherit"],
+		});
+		if ((await p.exited) !== 0) {
+			log.warn("gh auth refresh failed. Run it, then `kanbot board create`.");
+			return false;
+		}
+	}
+	const choice = askBoard(ask, say, parseProjectUrl);
+	if (choice.kind === "skip") return false;
+	let url = "";
+	const ok = await tryStep(
+		async () => {
+			const board =
+				choice.kind === "link"
+					? await linkBoard(root, choice.owner, choice.number)
+					: await setupBoard(root);
+			if (!board) return;
+			if (choice.kind === "link") printWorkflows(await loadConfig(root), board);
+			url = workflowsUrl(board);
+		},
+		choice.kind === "link" ? "kanbot board link" : "kanbot board create",
+	);
+	if (!ok || !url) return false;
+	if (confirm(ask, "Open the Workflows page now?", true)) openBrowser(url);
+	return true;
+}
+
+async function authStatus() {
+	const p = Bun.spawn(["gh", "auth", "status"], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [out, err] = await Promise.all([
+		new Response(p.stdout).text(),
+		new Response(p.stderr).text(),
+	]);
+	await p.exited;
+	return `${out}${err}`;
+}
+
+async function writeCodeowners(root: string) {
+	const path = join(root, ".github", "CODEOWNERS");
+	if (existsSync(path)) return;
+	const login = (await run(["api", "user", "--jq", ".login"])).trim();
+	await Bun.write(
+		path,
+		`# Human reviewers. kanbot acts as your account, so this documents ownership\n# rather than triggering review requests for your own PRs.\n* @${login}\n`,
+	);
+	log.info(`+ .github/CODEOWNERS (@${login})`);
+}
+
 async function appendGitignore(root: string) {
 	const path = join(root, ".gitignore");
 	const current = existsSync(path) ? await Bun.file(path).text() : "";

package/src/commands/report.ts

@@ -0,0 +1,74 @@
+import { defineCommand } from "citty";
+import { LABELS, loadConfig } from "../config.ts";
+import { waitingOnHuman } from "../daemon/derive.ts";
+import { takeSnapshot } from "../daemon/snapshot.ts";
+import { fetchActivity, signed } from "../github/api.ts";
+import { Gh } from "../github/gh.ts";
+import { marker } from "../github/markers.ts";
+import { loadBoard, postStatusUpdate } from "../github/project.ts";
+import { Trust } from "../github/trust.ts";
+import { log } from "../log.ts";
+import { buildReport, parseSince, renderReport } from "../report.ts";
+
+export default defineCommand({
+	meta: {
+		name: "report",
+		description:
+			"Show flow metrics: merged PRs, cycle time, wait on you, fix loops, needs-human causes",
+	},
+	args: {
+		since: {
+			type: "string",
+			description: "Start of the period: 7d, 2w, 12h or YYYY-MM-DD",
+			default: "7d",
+		},
+		post: {
+			type: "boolean",
+			description: "Also post it to the board's Status updates",
+			default: false,
+		},
+		json: {
+			type: "boolean",
+			description: "Print JSON instead of text",
+			default: false,
+		},
+	},
+	async run({ args }) {
+		const since = parseSince(args.since);
+		const config = await loadConfig(process.cwd());
+		const gh = new Gh(config.repo);
+		const board = await loadBoard(gh, config);
+
+		const [activity, snapshot] = await Promise.all([
+			fetchActivity(gh, since),
+			takeSnapshot(gh, board, new Trust(gh)),
+		]);
+		const open = snapshot.items.filter(
+			(i) => i.issue.state === "OPEN" && i.column !== "done",
+		);
+		const report = buildReport(
+			activity,
+			{
+				waiting: waitingOnHuman(snapshot, config).length,
+				limit: config.wip.awaitingHuman,
+				needsHuman: open.filter((i) =>
+					i.issue.labels.includes(LABELS.needsHuman),
+				).length,
+				active: open.length,
+			},
+			since,
+		);
+
+		const text = renderReport(report);
+		console.log(args.json ? JSON.stringify(report, null, 2) : text);
+
+		if (args.post) {
+			await postStatusUpdate(gh, board, {
+				body: `${signed(gh, text)}\n\n${marker("report")}`,
+				status: report.health,
+				startDate: report.since.slice(0, 10),
+			});
+			if (!args.json) log.info(`Posted to Status updates: ${board.url}`);
+		}
+	},
+});

package/src/commands/status.ts

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { defineCommand } from "citty";
 import { COLUMN_KEYS, loadConfig } from "../config.ts";
-import { waitingOnHuman } from "../daemon/derive.ts";
+import { waitingOnHuman, wipFull } from "../daemon/derive.ts";
 import { takeSnapshot } from "../daemon/snapshot.ts";
 import { State } from "../daemon/state.ts";
 import { Gh } from "../github/gh.ts";
@@ -56,7 +56,15 @@ export default defineCommand({
 				const ago = since ? age(since) : "?";
 				return `  ${ago.padStart(4)}  #${item.issue.number} ${why} · ${item.issue.title}\n        ${url}`;
 			});
-			console.log(`\nwaiting on you:\n${rows.join("\n")}`);
+			const limit = config.wip.awaitingHuman;
+			console.log(
+				`\nwaiting on you${limit === null ? "" : ` (${waiting.length}/${limit})`}:\n${rows.join("\n")}`,
+			);
+		}
+		if (wipFull(snapshot, config).full) {
+			console.log(
+				"WIP limit reached: no new Ready cards start until you clear some.",
+			);
 		}
 
 		const state = await new State(root).load();

package/src/config.ts

@@ -81,6 +81,20 @@ export const ConfigSchema = z.object({
 		.describe(
 			"Max concurrent agent workers. Each exploratory variant is one worker.",
 		),
+	wip: z
+		.object({
+			awaitingHuman: z
+				.number()
+				.int()
+				.min(1)
+				.nullable()
+				.default(null)
+				.describe(
+					"When this many items wait on you (`kanbot status`), no new Ready card starts. Started work runs on. null: no limit.",
+				),
+		})
+		.prefault({})
+		.describe("Work-in-progress limits."),
 	pollSeconds: z
 		.number()
 		.int()

package/src/daemon/derive.ts

@@ -242,6 +242,7 @@ export function derive(snapshot: Snapshot, ctx: DeriveContext) {
 	};
 
 	const items = [...snapshot.items].sort((a, b) => a.position - b.position);
+	const full = wipFull(snapshot, config).full;
 
 	for (const item of items) {
 		const { issue } = item;
@@ -296,6 +297,8 @@ export function derive(snapshot: Snapshot, ctx: DeriveContext) {
 						actions.push({ kind: "waiting", item, blockers });
 					break;
 				}
+				// Too much waits on the human: don't start new cards.
+				if (item.column === "ready" && !issue.prs.length && full) break;
 				const n = exploreCount(issue.labels);
 				const variants =
 					n === null ? [null] : Array.from({ length: n }, (_, i) => i + 1);
@@ -621,3 +624,10 @@ export function waitingOnHuman(snapshot: Snapshot, config: Config): Waiting[] {
 	const key = (w: Waiting) => w.since ?? "\uffff";
 	return out.sort((a, b) => key(a).localeCompare(key(b)));
 }
+
+/** The `wip.awaitingHuman` limit. When full, no new Ready card starts. */
+export function wipFull(snapshot: Snapshot, config: Config) {
+	const limit = config.wip.awaitingHuman;
+	const waiting = limit === null ? 0 : waitingOnHuman(snapshot, config).length;
+	return { waiting, limit, full: limit !== null && waiting >= limit };
+}

package/src/daemon/loop.ts

@@ -18,7 +18,7 @@ import { log } from "../log.ts";
 import { claude } from "../providers/claude.ts";
 import { codex } from "../providers/codex.ts";
 import type { Provider } from "../providers/types.ts";
-import { type Action, derive, type Job, schedule } from "./derive.ts";
+import { type Action, derive, type Job, schedule, wipFull } from "./derive.ts";
 import { Worktrees } from "./git.ts";
 import { acquireLock } from "./lock.ts";
 import { Notifier } from "./notify.ts";
@@ -75,6 +75,7 @@ export async function runDaemon(root: string, opts: RunOptions) {
 	let wake: () => void = () => {};
 	// kanbot-review PRs vanish from the snapshot when closed; clean up after them.
 	let prOnly = new Set<number>();
+	let wasFull = false;
 	let stopping = false;
 
 	const stop = () => {
@@ -125,6 +126,15 @@ export async function runDaemon(root: string, opts: RunOptions) {
 			failures: state.failures,
 			now: Date.now(),
 		});
+		const wip = wipFull(snapshot, config);
+		if (wip.full !== wasFull) {
+			if (wip.full)
+				log.warn(
+					`WIP limit: ${wip.waiting} item(s) wait on you (limit ${wip.limit}). No new Ready cards start. See \`kanbot status\`.`,
+				);
+			else log.info("WIP limit cleared; Ready cards start again.");
+			wasFull = wip.full;
+		}
 		const nowPrOnly = new Set(
 			snapshot.items.filter((i) => i.issue.prOnly).map((i) => i.issue.number),
 		);

package/src/github/api.ts

@@ -1,4 +1,5 @@
 import type { Checks, Comment, Issue, IssueRef, PR } from "../daemon/types.ts";
+import type { Activity } from "../report.ts";
 import type { Gh } from "./gh.ts";
 
 const COMMENT = "id databaseId author { login } body createdAt";
@@ -393,3 +394,48 @@ export async function copilotReviewRule(gh: Gh, branch: string) {
 	);
 	return rules.find((r) => r.type === "copilot_code_review") ?? null;
 }
+
+const ACTIVITY_QUERY = `
+query($q: String!, $after: String) {
+	search(query: $q, type: ISSUE, first: 50, after: $after) {
+		nodes {
+			__typename
+			... on PullRequest {
+				number title url headRefName createdAt mergedAt
+				comments(last: 100) { nodes { body createdAt } }
+			}
+			... on Issue {
+				number title url createdAt
+				comments(last: 100) { nodes { body createdAt } }
+			}
+		}
+		pageInfo { hasNextPage endCursor }
+	}
+}`;
+
+/** Issues and PRs updated since `since`, with comments, for `kanbot report`. */
+export async function fetchActivity(gh: Gh, since: Date): Promise<Activity[]> {
+	const q = `repo:${gh.repo} updated:>=${since.toISOString().slice(0, 10)}`;
+	const out: Activity[] = [];
+	let after: string | null = null;
+	do {
+		// biome-ignore lint/suspicious/noExplicitAny: raw GraphQL shape, mapped below
+		const data: any = await gh.query(ACTIVITY_QUERY, { q, after });
+		for (const n of data.search.nodes) {
+			if (n.__typename !== "PullRequest" && n.__typename !== "Issue") continue;
+			out.push({
+				kind: n.__typename === "PullRequest" ? "pr" : "issue",
+				number: n.number,
+				title: n.title,
+				url: n.url,
+				headRefName: n.headRefName,
+				createdAt: n.createdAt,
+				mergedAt: n.mergedAt,
+				comments: n.comments.nodes,
+			});
+		}
+		const page = data.search.pageInfo;
+		after = page.hasNextPage ? page.endCursor : null;
+	} while (after);
+	return out;
+}

package/src/github/project.ts

@@ -274,6 +274,39 @@ export async function addToBoard(
 	if (res) await moveItem(gh, board, res.addProjectV2ItemById.item.id, column);
 }
 
+/**
+ * Built-in board workflows kanbot relies on, with the setting to pick.
+ * GitHub's API can read them but not enable them. `required`: kanbot needs it.
+ */
+export function neededWorkflows(config: Config) {
+	return [
+		{
+			name: "Item closed",
+			set: `set Status: ${config.columns.done}`,
+			required: true,
+		},
+		{
+			name: "Pull request merged",
+			set: `set Status: ${config.columns.done}`,
+			required: true,
+		},
+		{
+			name: "Auto-add to project",
+			set: `filter is:issue repo:${config.repo}`,
+			required: true,
+		},
+		{
+			name: "Item added to project",
+			set: `set Status: ${config.columns.ideas}`,
+			required: false,
+		},
+	];
+}
+
+/** The board's Workflows settings page. */
+export const workflowsUrl = (board: { url: string }) =>
+	`${board.url}/workflows`;
+
 /** Built-in board workflows; they can be read but not enabled via the API. */
 export async function boardWorkflows(gh: Gh, board: Board) {
 	const data = await gh.query<{
@@ -286,3 +319,25 @@ export async function boardWorkflows(gh: Gh, board: Board) {
 	);
 	return data.node.workflows.nodes;
 }
+
+export type StatusUpdate = {
+	body: string;
+	status: "ON_TRACK" | "AT_RISK" | "OFF_TRACK" | "INACTIVE" | "COMPLETE";
+	/** YYYY-MM-DD */
+	startDate: string;
+};
+
+/** Post to the board's "Status updates" in the project details. */
+export function postStatusUpdate(gh: Gh, board: Board, update: StatusUpdate) {
+	return gh.mutate<{
+		createProjectV2StatusUpdate: { statusUpdate: { id: string } };
+	}>(
+		"post project status update",
+		`mutation($p: ID!, $b: String!, $s: ProjectV2StatusUpdateStatus!, $d: Date!) {
+			createProjectV2StatusUpdate(input: { projectId: $p, body: $b, status: $s, startDate: $d }) {
+				statusUpdate { id }
+			}
+		}`,
+		{ p: board.id, b: update.body, s: update.status, d: update.startDate },
+	);
+}

package/src/known-hashes.json

@@ -22,10 +22,13 @@
 		"2c6c77a225c5b880eff023d4b3c1305bfc91bfb3",
 		"2ccb86b12e5af121b79ef9f53c2a35dbbdb2ddeb",
 		"53c73b1be4a1e8d863a52043eae4ca911c8be71b",
+		"5f23634074693b6d9116c2df07d0be7e7efbd10b",
+		"7fa56c70c75a2f4120b6d0de0eb6dba728e121ab",
 		"a24c0a655d6485e65bd5dea2a71f3afe67f04404",
 		"b5a2d074ea61f2552890ca1d78bf8a043d7b73b3",
 		"bde0364d60525598bbb28f1648d06d1407c62a73",
 		"cf3e95d137a5a58a273262bca6ba25fbc95fa037",
+		"e0fcf4ccb461a00302e8ddfe8f9543d58728191c",
 		"f9b76db4afbad14ad9d14dff805c71703099bdeb"
 	],
 	".agents/skills/kanbot-idea/SKILL.md": [