kanbot 0.0.0-stage → 0.2.0

package/src/jobs/run.ts

@@ -0,0 +1,569 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { z } from "zod";
+import { type AgentDef, getAgent } from "../agents/load.ts";
+import { type Config, LABELS } from "../config.ts";
+import {
+	type Action,
+	exploreCount,
+	type FixJob,
+	type ImplementJob,
+	type Job,
+	type PlanJob,
+	type ReviewJob,
+	reviewPasses,
+	variantOf,
+} from "../daemon/derive.ts";
+import type { Worktrees } from "../daemon/git.ts";
+import type { Notifier } from "../daemon/notify.ts";
+import type { State } from "../daemon/state.ts";
+import {
+	addLabels,
+	addSubIssue,
+	createIssue,
+	createPR,
+	failedCheckLogs,
+	fetchIssue,
+	postComment,
+	react,
+	removeLabel,
+	replyToThread,
+	resolveThread,
+	updateIssueBody,
+	updatePRBody,
+} from "../github/api.ts";
+import type { Gh } from "../github/gh.ts";
+import {
+	embedJson,
+	marker,
+	withDescription,
+	withPlan,
+} from "../github/markers.ts";
+import { addToBoard, type Board, moveItem } from "../github/project.ts";
+import { log } from "../log.ts";
+import type { Provider } from "../providers/types.ts";
+import {
+	FixResult,
+	type ImplementResult,
+	jsonSchema,
+	PlanResult,
+	RESULT_SCHEMAS,
+	type ResultSchemaName,
+	ReviewResult,
+} from "../schemas/results.ts";
+import {
+	findingsList,
+	fixPrompt,
+	implementPrompt,
+	planPrompt,
+	reviewPrompt,
+} from "./prompts.ts";
+
+export type JobDeps = {
+	root: string;
+	config: Config;
+	gh: Gh;
+	board: Board;
+	agents: AgentDef[];
+	provider: Provider;
+	worktrees: Worktrees;
+	notify: Notifier;
+	state: State;
+};
+
+export class RateLimited extends Error {}
+
+/** Thrown when a job ended in a state the human must resolve; not retried. */
+export class NeedsHuman extends Error {}
+
+async function runAgent<N extends ResultSchemaName>(
+	deps: JobDeps,
+	job: Job,
+	agentName: string,
+	schema: N,
+	cwd: string,
+	prompt: string,
+): Promise<z.infer<(typeof RESULT_SCHEMAS)[N]>> {
+	const agent = getAgent(deps.agents, agentName);
+	const logDir = join(deps.root, ".kanbot", "logs");
+	await mkdir(logDir, { recursive: true });
+	const logFile = join(
+		logDir,
+		`${new Date().toISOString().replace(/[:.]/g, "-")}_${job.key.replace(/[^a-zA-Z0-9-]/g, "_")}.jsonl`,
+	);
+	log.info(
+		`▶ ${job.key} → ${agent.name} (${deps.provider.name}) log: ${logFile}`,
+	);
+	const res = await deps.provider.run({
+		agent,
+		agents: deps.agents,
+		prompt,
+		cwd,
+		schema: jsonSchema(schema),
+		timeoutMs: deps.config.timeoutMinutes[job.kind] * 60_000,
+		logFile,
+		repoRoot: deps.root,
+	});
+	if (!res.ok) {
+		if (res.rateLimited) throw new RateLimited(res.error);
+		throw new Error(res.error);
+	}
+	return RESULT_SCHEMAS[schema].parse(res.output) as z.infer<
+		(typeof RESULT_SCHEMAS)[N]
+	>;
+}
+
+/**
+ * One worktree per branch, not per job: git refuses to check out a branch that
+ * another worktree holds, and derive never runs two jobs on one branch at once.
+ */
+export function worktreeName(job: Job) {
+	const n = job.item.issue.number;
+	switch (job.kind) {
+		case "plan":
+			return `i${n}-plan`;
+		case "implement":
+			return `i${n}-v${job.variant ?? 1}`;
+		default:
+			return `i${n}-v${variantOf(job.pr.headRefName) ?? 1}`;
+	}
+}
+
+export function runJob(job: Job, deps: JobDeps): Promise<void> {
+	switch (job.kind) {
+		case "plan":
+			return plan(job, deps);
+		case "implement":
+			return implement(job, deps);
+		case "review":
+			return review(job, deps);
+		case "fix":
+			return fix(job, deps);
+	}
+}
+
+// ---- plan -------------------------------------------------------------------
+
+async function plan(job: PlanJob, deps: JobDeps) {
+	const { gh } = deps;
+	const { issue } = job.item;
+	await Promise.all(job.comments.map((c) => react(gh, c.id, "EYES")));
+	const cwd = await deps.worktrees.detached(worktreeName(job));
+	const result = await runAgent(
+		deps,
+		job,
+		"planner",
+		"plan-result",
+		cwd,
+		planPrompt(job, exploreCount(issue.labels)),
+	);
+	PlanResult.parse(result);
+
+	// Re-read so concurrent human edits to the description are kept.
+	const fresh = await fetchIssue(gh, issue.number);
+	await updateIssueBody(gh, issue.number, withPlan(fresh.body, result.plan));
+
+	const allowed = result.labels.filter(
+		(l) => l === LABELS.technical || l.startsWith(LABELS.typePrefix),
+	);
+	await addLabels(
+		gh,
+		issue.number,
+		allowed.filter((l) => !fresh.labels.includes(l)),
+	);
+
+	const created: string[] = [];
+	for (const ni of result.newIssues) {
+		const res = await createIssue(
+			gh,
+			ni.title,
+			`${ni.body}\n\n_Split from #${issue.number} by kanbot._\n${marker("created", issue.number)}`,
+		);
+		if (!res) continue;
+		if (ni.subIssue) await addSubIssue(gh, issue.id, res.node_id);
+		await addToBoard(gh, deps.board, res.node_id, ni.column);
+		created.push(`#${res.number}`);
+	}
+
+	const lines = [
+		`**Plan ${job.initial ? "drafted" : "updated"}.** ${result.summary}`,
+	];
+	const replyFor = new Map(result.replies.map((r) => [r.commentId, r.body]));
+	for (const c of job.comments) {
+		const reply =
+			replyFor.get(c.id) ?? "Noted; reflected in the plan where relevant.";
+		lines.push(`> ${excerpt(c.body)}\n\n${reply}`);
+	}
+	if (created.length) lines.push(`Created ${created.join(", ")}.`);
+	if (result.questions.length) {
+		lines.push(
+			`**Questions for you:**\n${result.questions.map((q) => `- ${q}`).join("\n")}`,
+		);
+	}
+	lines.push(
+		"_Comment to refine. Drag the card to **Ready** when the plan is approved._",
+	);
+	lines.push(
+		[marker("plan"), ...job.comments.map((c) => marker("re", c.id))].join("\n"),
+	);
+	await postComment(gh, issue.number, lines.join("\n\n"));
+	await Promise.all(job.comments.map((c) => react(gh, c.id, "THUMBS_UP")));
+}
+
+// ---- implement ----------------------------------------------------------------
+
+async function implement(job: ImplementJob, deps: JobDeps) {
+	const { gh, config, worktrees } = deps;
+	const { issue } = job.item;
+	if (job.item.column === "ready") {
+		await moveItem(gh, deps.board, job.item.itemId, "inProgress");
+		await addLabels(gh, issue.number, [LABELS.working]);
+	}
+
+	const resumed = await worktrees.remoteHas(job.branch);
+	const cwd = await worktrees.checkout(worktreeName(job), job.branch);
+	let result: z.infer<typeof ImplementResult> | null = null;
+	if (!resumed) {
+		const typeLabel = issue.labels
+			.find((l) => l.startsWith(LABELS.typePrefix))
+			?.slice(LABELS.typePrefix.length);
+		const agentName =
+			config.implementers[typeLabel ?? "default"] ??
+			config.implementers.default ??
+			"implementer-backend";
+		result = await runAgent(
+			deps,
+			job,
+			agentName,
+			"implement-result",
+			cwd,
+			implementPrompt(job, config.baseBranch),
+		);
+		if (result.status === "blocked") {
+			await addLabels(gh, issue.number, [LABELS.needsHuman]);
+			await postComment(
+				gh,
+				issue.number,
+				`**Implementation blocked${job.variant ? ` (approach ${job.variant})` : ""}.** ${result.blockedReason ?? ""}\n\nRemove \`${LABELS.needsHuman}\` once resolved and kanbot will retry.\n${marker("blocked", job.branch)}`,
+			);
+			deps.notify.send(
+				`Blocked: #${issue.number}`,
+				result.blockedReason ?? issue.title,
+				issue.url,
+			);
+			throw new NeedsHuman("agent reported blocked");
+		}
+		await worktrees.commitAll(
+			cwd,
+			`feat: ${result.prTitle} (#${issue.number})`,
+		);
+		if (
+			(await worktrees.commitsAhead(cwd, `origin/${config.baseBranch}`)) === 0
+		) {
+			throw new Error("agent finished without any changes");
+		}
+		await worktrees.push(cwd, job.branch);
+	} else {
+		log.info(
+			`${job.key}: branch ${job.branch} already pushed; opening PR only`,
+		);
+	}
+
+	const variant =
+		job.variant === null ? "" : ` [approach ${job.variant}/${job.variants}]`;
+	const body = [
+		withDescription(
+			"",
+			result
+				? absoluteImages(result.prBody, config.repo, job.branch)
+				: `Implements #${issue.number}.`,
+		),
+		result?.risks.length
+			? `### Risks\n${result.risks.map((r) => `- ${r}`).join("\n")}`
+			: "",
+		result?.testsRun.length
+			? `### Checks\n${result.testsRun.map((t) => `- ${t}`).join("\n")}`
+			: "",
+		job.variant === null
+			? ""
+			: `> Exploratory: approach ${job.variant} of ${job.variants}. Merging one closes the others.`,
+		`Closes #${issue.number}`,
+		marker("pr", issue.number),
+	]
+		.filter(Boolean)
+		.join("\n\n");
+	const pr = await createPR(gh, {
+		title: `${result?.prTitle ?? issue.title}${variant}`,
+		body,
+		head: job.branch,
+		base: config.baseBranch,
+	});
+	if (pr) {
+		const labels = issue.labels.filter(
+			(l) => l.startsWith(LABELS.typePrefix) || l === LABELS.technical,
+		);
+		if (job.variant !== null)
+			labels.push(`${LABELS.variantPrefix}${job.variant}`);
+		await addLabels(gh, pr.number, labels);
+		log.info(`✔ opened ${pr.html_url}`);
+	}
+}
+
+/** First line of a comment, cut at a word boundary, for quoting in replies. */
+export function excerpt(body: string, max = 120) {
+	const line = body.trim().split("\n")[0] ?? "";
+	if (line.length <= max) return line;
+	const cut = line.slice(0, max);
+	const space = cut.lastIndexOf(" ");
+	return `${(space > max / 2 ? cut.slice(0, space) : cut).trimEnd()}…`;
+}
+
+/** PR bodies don't render repo-relative images; point them at the branch. */
+export function absoluteImages(md: string, repo: string, branch: string) {
+	return md.replace(
+		/!\[([^\]]*)\]\((?!https?:|\/\/)(?:\.\/)?([^)\s]+)\)/g,
+		(_, alt, path) =>
+			`![${alt}](https://github.com/${repo}/blob/${branch}/${path}?raw=true)`,
+	);
+}
+
+// ---- review -------------------------------------------------------------------
+
+const PASS_AGENT = { 1: "reviewer-code", 2: "reviewer-spec" } as const;
+const PASS_NAME = { 1: "code", 2: "spec" } as const;
+
+async function review(job: ReviewJob, deps: JobDeps) {
+	const cwd = await deps.worktrees.checkout(
+		worktreeName(job),
+		job.pr.headRefName,
+	);
+	const result = await runAgent(
+		deps,
+		job,
+		PASS_AGENT[job.pass],
+		"review-result",
+		cwd,
+		reviewPrompt(job, deps.config.baseBranch),
+	);
+	ReviewResult.parse(result);
+	const icon = result.verdict === "approve" ? "✅" : "🛠️";
+	const body = [
+		`### ${icon} Agent review ${job.pass}/${reviewPasses(job.item.issue).length} (${PASS_NAME[job.pass]}): ${result.verdict === "approve" ? "approve" : "changes requested"}`,
+		result.summary,
+		result.findings.length ? findingsList(result.findings) : "_No findings._",
+		marker("review", job.pass),
+		embedJson("findings", result.findings),
+	].join("\n\n");
+	await postComment(deps.gh, job.pr.number, body);
+}
+
+// ---- fix ----------------------------------------------------------------------
+
+async function fix(job: FixJob, deps: JobDeps) {
+	const { gh, worktrees, config } = deps;
+	const { pr } = job;
+	const cwd = await worktrees.checkout(worktreeName(job), pr.headRefName);
+	if (job.reason.type === "conflict") return mergeBase(job, deps, cwd);
+	const before = await worktrees.head(cwd);
+	const logs =
+		job.reason.type === "ci"
+			? await failedCheckLogs(gh, pr.headSha).catch(() => null)
+			: null;
+	const result = await runAgent(
+		deps,
+		job,
+		"fixer",
+		"fix-result",
+		cwd,
+		fixPrompt(job, config.baseBranch, logs),
+	);
+	FixResult.parse(result);
+
+	await worktrees.commitAll(
+		cwd,
+		`fix: address ${job.reason.type === "ci" ? "CI failure" : "review feedback"} (#${job.item.issue.number})`,
+	);
+	const changed = (await worktrees.head(cwd)) !== before;
+	if (changed) await worktrees.push(cwd, pr.headRefName);
+	if (result.prBody) {
+		const desc = absoluteImages(result.prBody, config.repo, pr.headRefName);
+		await updatePRBody(gh, pr.number, withDescription(pr.body, desc));
+	}
+	const by = new Map(result.addressed.map((a) => [a.ref, a]));
+	const pushed = changed ? "Pushed fixes." : "No code changes.";
+
+	const r = job.reason;
+	if (r.type === "review") {
+		const lines = r.findings.map((f) => {
+			const a = by.get(f.id);
+			return `- ${a?.resolved ? "✅" : "⏭️"} **${f.id}** ${a?.reply ?? "Not addressed."}`;
+		});
+		await postComment(
+			gh,
+			pr.number,
+			[
+				`**Addressed agent review ${r.pass}/${reviewPasses(job.item.issue).length}.** ${result.summary} ${pushed}`,
+				lines.join("\n"),
+				marker("fixed", r.pass),
+			].join("\n\n"),
+		);
+		return;
+	}
+	if (r.type === "ci") {
+		await postComment(
+			gh,
+			pr.number,
+			`**CI fix attempt.** ${result.summary} ${pushed}\n\n${marker("ci", pr.headSha)}`,
+		);
+		return;
+	}
+
+	// Answer every thread so it no longer has a human or Copilot as last word.
+	let open = 0;
+	for (const t of r.threads) {
+		const a = by.get(t.id);
+		await replyToThread(
+			gh,
+			t.id,
+			`${a?.reply ?? "Looked at this but made no change."}\n\n${marker("re", t.id)}`,
+		);
+		if (a?.resolved) await resolveThread(gh, t.id);
+		else open++;
+	}
+	if (r.type === "copilot") return;
+	if (r.comments.length) {
+		const lines = r.comments.map((c) => {
+			const a = by.get(c.id);
+			if (!a?.resolved) open++;
+			return `> ${excerpt(c.body)}\n\n${a?.reply ?? "Noted."}`;
+		});
+		await postComment(
+			gh,
+			pr.number,
+			[
+				`**Feedback round.** ${result.summary} ${pushed}`,
+				...lines,
+				r.comments.map((c) => marker("re", c.id)).join("\n"),
+			].join("\n\n"),
+		);
+	}
+	const msg = open
+		? `${open} item(s) need your input.`
+		: "All feedback addressed — ready for another look.";
+	if (!r.comments.length)
+		await postComment(
+			gh,
+			pr.number,
+			`${msg} ${pushed}\n\n${marker("feedback-round")}`,
+		);
+	deps.notify.send(
+		`PR #${pr.number}: ${open ? "needs input" : "feedback addressed"}`,
+		msg,
+		pr.url,
+	);
+}
+
+// ---- merge base ---------------------------------------------------------------
+
+const CONFLICT_MARKER = /^(<{7}|>{7})( |$)/m;
+
+/** Merge the base branch into a conflicting PR; the fixer resolves conflicts. */
+async function mergeBase(job: FixJob, deps: JobDeps, cwd: string) {
+	const { gh, worktrees, config } = deps;
+	const { pr } = job;
+	const base = `origin/${config.baseBranch}`;
+	const files = await worktrees.merge(cwd, base);
+	let summary = "It merged cleanly.";
+	if (files.length) {
+		const result = await runAgent(
+			deps,
+			job,
+			"fixer",
+			"fix-result",
+			cwd,
+			fixPrompt(job, config.baseBranch, files.map((f) => `- ${f}`).join("\n")),
+		);
+		FixResult.parse(result);
+		const left: string[] = [];
+		for (const f of files) {
+			const file = Bun.file(join(cwd, f));
+			if ((await file.exists()) && CONFLICT_MARKER.test(await file.text()))
+				left.push(f);
+		}
+		if (left.length)
+			throw new Error(`conflict markers left in ${left.join(", ")}`);
+		summary = `${result.summary} Resolved conflicts in ${files.map((f) => `\`${f}\``).join(", ")}.`;
+	}
+	await worktrees.concludeMerge(cwd);
+	await worktrees.commitAll(
+		cwd,
+		`fix: resolve merge conflicts (#${job.item.issue.number})`,
+	);
+	if (!(await worktrees.isAncestor(cwd, base)))
+		throw new Error(`${base} was not merged`);
+	await worktrees.push(cwd, pr.headRefName);
+	await postComment(
+		gh,
+		pr.number,
+		`**Merged \`${config.baseBranch}\`.** ${summary}\n\n${marker("conflict", pr.headSha)}`,
+	);
+}
+
+// ---- deterministic actions ----------------------------------------------------
+
+export async function applyAction(action: Action, deps: JobDeps) {
+	const { gh } = deps;
+	switch (action.kind) {
+		case "move":
+			log.info(`#${action.item.issue.number} → ${action.to} (${action.why})`);
+			return moveItem(gh, deps.board, action.item.itemId, action.to);
+		case "label":
+			await addLabels(gh, action.number, action.add);
+			for (const l of action.remove) await removeLabel(gh, action.number, l);
+			return;
+		case "agentReviewed":
+			await addLabels(gh, action.pr.number, [LABELS.agentReviewed]);
+			await postComment(
+				gh,
+				action.pr.number,
+				`**Agent review complete.** Ready for you to test and merge.\n\n${marker("ready")}`,
+			);
+			deps.notify.send(
+				`Ready to test: PR #${action.pr.number}`,
+				action.pr.title,
+				action.pr.url,
+			);
+			return;
+		case "compare": {
+			const rows = action.prs.map(
+				(p) =>
+					`| ${p.labels.find((l) => l.startsWith(LABELS.variantPrefix)) ?? "?"} | #${p.number} | ${p.title} |`,
+			);
+			await postComment(
+				gh,
+				action.item.issue.number,
+				`**All ${action.prs.length} approaches are agent-reviewed.** Try them and merge the one you want; the others are closed automatically.\n\n| Variant | PR | Title |\n|---|---|---|\n${rows.join("\n")}\n\n${marker("compare")}`,
+			);
+			deps.notify.send(
+				`Compare approaches: #${action.item.issue.number}`,
+				action.item.issue.title,
+				action.item.issue.url,
+			);
+			return;
+		}
+		case "needsHuman":
+			await addLabels(gh, action.number, [LABELS.needsHuman]);
+			await postComment(
+				gh,
+				action.number,
+				`**kanbot needs a human.** ${action.why}\n\nRemove \`${LABELS.needsHuman}\` to let agents retry.\n${marker("needs-human")}`,
+			);
+			deps.notify.send(`Needs human: #${action.number}`, action.why);
+			return;
+		case "resetFailures":
+			deps.state.resetFailures(action.prefix);
+			return;
+		case "cleanup":
+			return deps.worktrees.remove(`i${action.number}-`);
+	}
+}

package/src/known-hashes.json

@@ -0,0 +1,132 @@
+{
+	".agents/skills/accessibility/SKILL.md": [
+		"bb8c5148899685168324b8fda3524937e3943b32"
+	],
+	".agents/skills/approach-designer/SKILL.md": [
+		"7fbf6e80562b59e94c8b9615d777afca8a769d29"
+	],
+	".agents/skills/code-review/SKILL.md": [
+		"a35bdecaeb1b6a2469a6330d2cef42a9d61409fe"
+	],
+	".agents/skills/frontend-design/LICENSE.txt": [
+		"f433b1a53f5b830a205fd2df78e2b34974656c7b"
+	],
+	".agents/skills/frontend-design/SKILL.md": [
+		"8ac4bf9b37f7b42ead4b65c35e0e9890fb5354e8"
+	],
+	".agents/skills/issue-splitting/SKILL.md": [
+		"01625372d68a81347bf401e8603084420922d04e"
+	],
+	".agents/skills/kanbot-admin/SKILL.md": [
+		"3789c559be9fb6a78f82708ae9857395a5556f6b",
+		"e427c711b532963c0916f07ecc6b11e9b47cb9fa"
+	],
+	".agents/skills/kanbot-idea/SKILL.md": [
+		"8ab28cec8d3f30250ffe080106d0de8e3c2eaa8a"
+	],
+	".agents/skills/plan-template/SKILL.md": [
+		"47a5dbbd2870883ca42dd9410d224ef9c0c9979f",
+		"79cfd0bf36110b5d6f452e6400161609b11df0d6",
+		"7bfde45995efaf515e45ccec09c204178203fdb7"
+	],
+	".agents/skills/pr-description/SKILL.md": [
+		"1db6eb751e0bb1ea0014a2b414e04f6af59b1b2d",
+		"6b0cca1be3abe8d031159c94e5d3b4f20307d600",
+		"7e477762c9c5f09ce6d5d51ccd9138ce9743baa8"
+	],
+	".agents/skills/project-conventions/SKILL.md": [
+		"81d9ff980a15a6f901010646b800b3e6e379e4b0",
+		"dabf1dadc148c020496d8f2f9bb8de6269f56479"
+	],
+	".agents/skills/project-memory/facts/.gitkeep": [
+		"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"
+	],
+	".agents/skills/project-memory/SKILL.md": [
+		"d354e11310db01362ec2bf5eec1080db77ac053d"
+	],
+	".agents/skills/spec-review/SKILL.md": [
+		"03e44fe4f23b04f1b11c907936ee9f6c7c8131f0",
+		"f455d1007d589602e5afce0dac4f00d78aa7c67a"
+	],
+	".agents/skills/tdd/SKILL.md": ["5e6b20868e02ae24f6d25824bac431143bd43021"],
+	".agents/skills/user-stories/SKILL.md": [
+		"1b37f8e59c15b934d555070a63d4f0d3939a007f",
+		"1b5d229d043c1bfbd84aecd9ee6191b1d473f1d8"
+	],
+	".agents/skills/verify-ui/SKILL.md": [
+		"c67a0e1d6a1c1d9adf59dd154160ccf58519ea72",
+		"f4d3d07c0ec28a9961d919356d0b4e572b724b43"
+	],
+	".github/ISSUE_TEMPLATE/config.yml": [
+		"0086358db1eb971c0cfa8739c27518bbc18a5ff4"
+	],
+	".github/ISSUE_TEMPLATE/technical.yml": [
+		"7e9d95fbb7192f8116ecfc870e6eb07c06e235a6"
+	],
+	".github/ISSUE_TEMPLATE/user-story.yml": [
+		"d26a148970ba6323d9cfdd86924cb2e82e68b705"
+	],
+	".github/pull_request_template.md": [
+		"57cfbc21472a94ccccb19ef6f19e87a473925649"
+	],
+	".github/workflows/ci.yml": ["dce7bcf80cef91c10923829eb5893d2b311b58e5"],
+	".github/workflows/kanbot-merged.yml": [
+		"8daaea63e23cf1e0d37821bfadaf60018a448de2"
+	],
+	".kanbot/agents/approach-designer.md": [
+		"7e5f8c16c4d4a4e261bccc5dc8b4fff2d3046a72"
+	],
+	".kanbot/agents/explorer.md": [
+		"4346bd34d438932f0a912ad0aad3d5f789e1e7dd",
+		"f85fe4782bdce4a691fa4ab41fb8195d52b70209"
+	],
+	".kanbot/agents/fixer.md": [
+		"109c8974fe2d70f5f514f33d97761740f589a6c4",
+		"7c98cf1dc3e798e0e5856fd95a3d78d378884def",
+		"810871ec49fd7be56d111c7df176d22c66748a0f"
+	],
+	".kanbot/agents/implementer-backend.md": [
+		"5d454e29260ba8df0ef6e21f1ece9d02a472d4ed",
+		"6fefffb02bb5551631839abd0863379e58bc7dcc"
+	],
+	".kanbot/agents/implementer-docs.md": [
+		"082da045a20bc914f29839e026027b6715c184a9",
+		"c5f01ac3d377133caab5b13422f1e73608d6357e"
+	],
+	".kanbot/agents/implementer-frontend.md": [
+		"0aa9b0e70c3057138b4255ee3d270ac04fc8ab0e",
+		"45a6e3b8f6e6f5a95dac865126c5649dab115fc5"
+	],
+	".kanbot/agents/implementer-technical.md": [
+		"c95dff48eed5db4aadf10d0a47e7ec1285937ebf",
+		"e4bbddb0a810313fb3a6ed3983b3b9335279feef"
+	],
+	".kanbot/agents/plan-critic.md": ["cd6dd133f4611bd86fe27f8539a62a805e4df6c9"],
+	".kanbot/agents/planner.md": [
+		"2283cf8bf6d27b8bbf721f97bb45cd40eaa6d39d",
+		"bdb111213cced70583157edad658247972dcbe45"
+	],
+	".kanbot/agents/reviewer-code.md": [
+		"398035214b63ceb3469a3b3384b07209e4cd63dd",
+		"61f3a45642ca954c6d4a5f41083f0a25f78d2b51"
+	],
+	".kanbot/agents/reviewer-spec.md": [
+		"11c86a654a0b715777b23bfb699a4f0d6cfe91de",
+		"ab8951ab296e96b01f419243d8acfc99c7e64b1c"
+	],
+	".kanbot/agents/test-writer.md": [
+		"dcef7f611a307229974fef4098d53816d7db0555",
+		"ec81c44c021053fae0612683a61e8414634359a0"
+	],
+	".kanbot/agents/ui-verifier.md": [
+		"38615159a8fe7b1e99cacedc49c0be53c69b90d4",
+		"a73abf7e72c654fde41df51b43a5879170978cb0"
+	],
+	"AGENTS.md": [
+		"3da9115cbf52b7b7d0feb8325503a8caf43ff2c7",
+		"b821013b5be7051327b349eda603218590a41f33",
+		"cf7ef593ccfda953055dfb76b3e9c267fc9637f6",
+		"e5b76bcbaf155b79a8ff3f2e70977cc0c589566b"
+	],
+	"CLAUDE.md": ["43c994c2d3617f947bcb5adf1933e21dabe46bb5"]
+}

package/src/log.ts

@@ -0,0 +1,11 @@
+const ts = () => new Date().toISOString().slice(11, 19);
+
+export const log = {
+	verbose: false,
+	info: (msg: string) => console.log(`${ts()} ${msg}`),
+	warn: (msg: string) => console.warn(`${ts()} ⚠ ${msg}`),
+	error: (msg: string) => console.error(`${ts()} ✖ ${msg}`),
+	debug: (msg: string) => {
+		if (log.verbose) console.log(`${ts()} · ${msg}`);
+	},
+};