opencodekit 0.12.4 → 0.12.5

package/dist/template/.opencode/plugin/beads.ts

@@ -1,1419 +0,0 @@
-import { createHash } from "crypto";
-import { type Plugin, tool } from "@opencode-ai/plugin";
-
-// =============================================================================
-// Types
-// =============================================================================
-
-interface TaskState {
-	currentTask: string | null;
-	reservedFiles: Set<string>;
-	team: string;
-	role: string;
-	initialized: boolean;
-	agentId: string;
-}
-
-interface Task {
-	id: string;
-	title: string;
-	status?: string;
-	priority?: number;
-	type?: string;
-	tags?: string[];
-	description?: string;
-}
-
-interface LockData {
-	path: string;
-	agent: string;
-	reason?: string;
-	created: number;
-	expires: number;
-	task: string | null;
-}
-
-interface Message {
-	id: string;
-	from: string;
-	to: string;
-	subj: string;
-	body?: string;
-	importance: string;
-	thread?: string;
-	global?: boolean;
-	at: number;
-	read: boolean;
-}
-
-interface BdListResult {
-	tasks: Task[];
-	error?: string;
-}
-
-interface BdSingleResult {
-	task?: Task;
-	id?: string;
-	output?: string;
-	error?: string;
-}
-
-interface BdGenericResult {
-	output?: string;
-	error?: string;
-}
-
-// =============================================================================
-// Plugin
-// =============================================================================
-
-export const BeadsCorePlugin: Plugin = async ({ $, directory }) => {
-	// Generate deterministic agent ID from directory + process
-	const agentId = `agent-${createHash("md5")
-		.update(`${directory}-${process.pid}`)
-		.digest("hex")
-		.slice(0, 8)}`;
-
-	const state: TaskState = {
-		currentTask: null,
-		reservedFiles: new Set(),
-		team: "default",
-		role: "",
-		initialized: false,
-		agentId,
-	};
-
-	const RESERVATIONS_DIR = ".reservations";
-
-	// =============================================================================
-	// Shell Helpers
-	// =============================================================================
-
-	// (Removed unused shell/shellQuiet helpers)
-
-	// =============================================================================
-	// Typed BD CLI Wrappers
-	// =============================================================================
-
-	async function bdList(
-		opts: {
-			status?: string;
-			sort?: string;
-			reverse?: boolean;
-			label?: string;
-			assignee?: string;
-			type?: string;
-			priorityMin?: number;
-			priorityMax?: number;
-			limit?: number;
-		} = {},
-	): Promise<{ tasks: Task[]; error?: string }> {
-		try {
-			const args = ["list", "--json"];
-			if (opts.status) args.push("--status", opts.status);
-			if (opts.sort) args.push("--sort", opts.sort);
-			if (opts.reverse) args.push("--reverse");
-			if (opts.label) args.push("--label", opts.label);
-			if (opts.assignee) args.push("--assignee", opts.assignee);
-			if (opts.type) args.push("--type", opts.type);
-			if (opts.priorityMin !== undefined)
-				args.push("--priority-min", String(opts.priorityMin));
-			if (opts.priorityMax !== undefined)
-				args.push("--priority-max", String(opts.priorityMax));
-			if (opts.limit) args.push("--limit", String(opts.limit));
-			const result = await $`bd ${args}`.cwd(directory).text();
-			const parsed = JSON.parse(result);
-			return { tasks: Array.isArray(parsed) ? parsed : [] };
-		} catch (e) {
-			return { tasks: [], error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdReady(
-		opts: {
-			sort?: string;
-			limit?: number;
-			assignee?: string;
-			label?: string;
-			unassigned?: boolean;
-		} = {},
-	): Promise<{ tasks: Task[]; error?: string }> {
-		try {
-			const args = ["ready", "--json"];
-			if (opts.sort) args.push("--sort", opts.sort);
-			if (opts.limit) args.push("--limit", String(opts.limit));
-			if (opts.assignee) args.push("--assignee", opts.assignee);
-			if (opts.label) args.push("--label", opts.label);
-			if (opts.unassigned) args.push("--unassigned");
-			const result = await $`bd ${args}`.cwd(directory).text();
-			const parsed = JSON.parse(result);
-			return { tasks: Array.isArray(parsed) ? parsed : [] };
-		} catch (e) {
-			return { tasks: [], error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdShow(id: string): Promise<{ task?: Task; error?: string }> {
-		try {
-			const result = await $`bd show ${id} --json`.cwd(directory).text();
-			return { task: JSON.parse(result) };
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdCreate(
-		title: string,
-		opts: {
-			priority?: number;
-			type?: string;
-			description?: string;
-			parent?: string;
-			tags?: string[];
-			deps?: string[];
-			assignee?: string;
-			estimate?: number; // minutes
-			acceptance?: string;
-		} = {},
-	): Promise<{ id?: string; error?: string }> {
-		try {
-			const args = ["create", title, "-p", String(opts.priority ?? 2)];
-			if (opts.type && opts.type !== "task") args.push("--type", opts.type);
-			if (opts.description) args.push("--description", opts.description);
-			if (opts.parent) args.push("--parent", opts.parent);
-			if (opts.tags?.length) args.push("--labels", opts.tags.join(","));
-			if (opts.deps?.length) args.push("--deps", opts.deps.join(","));
-			if (opts.assignee) args.push("--assignee", opts.assignee);
-			if (opts.estimate !== undefined)
-				args.push("--estimate", String(opts.estimate));
-			if (opts.acceptance) args.push("--acceptance", opts.acceptance);
-			args.push("--json");
-
-			const result = await $`bd ${args}`.cwd(directory).text();
-			// bd create may output warnings before JSON, extract JSON
-			const jsonMatch = result.match(/\{[\s\S]*\}/);
-			if (jsonMatch) {
-				const parsed = JSON.parse(jsonMatch[0]);
-				return { id: parsed.id };
-			}
-			return { id: result.trim() };
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdUpdate(
-		id: string,
-		opts: {
-			status?: string;
-			addLabel?: string;
-			removeLabel?: string;
-			setLabels?: string;
-			title?: string;
-			description?: string;
-			notes?: string;
-			priority?: number;
-			assignee?: string;
-			estimate?: string;
-			removeDep?: string;
-			addDep?: string;
-		},
-	): Promise<{ error?: string }> {
-		try {
-			const args = ["update", id];
-			if (opts.status) args.push("--status", opts.status);
-			if (opts.addLabel) args.push("--add-label", opts.addLabel);
-			if (opts.removeLabel) args.push("--remove-label", opts.removeLabel);
-			if (opts.setLabels) args.push("--set-labels", opts.setLabels);
-			if (opts.title) args.push("--title", opts.title);
-			if (opts.description) args.push("--description", opts.description);
-			if (opts.notes) args.push("--notes", opts.notes);
-			if (opts.priority !== undefined)
-				args.push("--priority", String(opts.priority));
-			if (opts.assignee) args.push("--assignee", opts.assignee);
-			if (opts.estimate) args.push("--estimate", opts.estimate);
-			if (opts.removeDep) args.push("--remove-dep", opts.removeDep);
-			if (opts.addDep) args.push("--add-dep", opts.addDep);
-			await $`bd ${args}`.cwd(directory).quiet();
-			return {};
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdClose(
-		id: string,
-		reason: string,
-	): Promise<{ error?: string }> {
-		try {
-			await $`bd close ${id} --reason ${reason}`.cwd(directory).quiet();
-			return {};
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdReopen(id: string): Promise<{ error?: string }> {
-		try {
-			await $`bd reopen ${id}`.cwd(directory).quiet();
-			return {};
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdSearch(
-		query: string,
-	): Promise<{ tasks: Task[]; error?: string }> {
-		try {
-			const result = await $`bd search ${query} --json`.cwd(directory).text();
-			const parsed = JSON.parse(result);
-			return { tasks: Array.isArray(parsed) ? parsed : [] };
-		} catch (e) {
-			return { tasks: [], error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdDepAdd(
-		child: string,
-		parent: string,
-		type = "blocks",
-	): Promise<{ error?: string }> {
-		try {
-			await $`bd dep add ${child} ${parent} --type ${type}`
-				.cwd(directory)
-				.quiet();
-			return {};
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdDepRemove(
-		child: string,
-		parent: string,
-	): Promise<{ error?: string }> {
-		try {
-			await $`bd dep remove ${child} ${parent}`.cwd(directory).quiet();
-			return {};
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdDepTree(
-		id: string,
-	): Promise<{ output?: string; error?: string }> {
-		try {
-			const result = await $`bd dep tree ${id}`.cwd(directory).text();
-			return { output: result.trim() };
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdSync(): Promise<{ output?: string; error?: string }> {
-		try {
-			const result = await $`bd sync`.cwd(directory).text();
-			return { output: result.trim() };
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdDoctor(): Promise<{ output?: string; error?: string }> {
-		try {
-			const result = await $`bd doctor`.cwd(directory).text();
-			return { output: result.trim() };
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	async function bdCleanup(
-		days: number,
-	): Promise<{ output?: string; error?: string }> {
-		try {
-			const result = await $`bd cleanup --older-than ${days} --force`
-				.cwd(directory)
-				.text();
-			return { output: result.trim() };
-		} catch (e) {
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	// =============================================================================
-	// File Locking (Atomic mkdir-based)
-	// =============================================================================
-
-	async function bdBlocked(): Promise<{ tasks: Task[]; error?: string }> {
-		try {
-			const result = await $`bd blocked --json`.cwd(directory).text();
-			const parsed = JSON.parse(result);
-			return { tasks: Array.isArray(parsed) ? parsed : [] };
-		} catch (e) {
-			return { tasks: [], error: e instanceof Error ? e.message : String(e) };
-		}
-	}
-
-	function lockDir(filePath: string): string {
-		const safe = filePath.replace(/[/\\]/g, "_").replace(/\.\./g, "_");
-		return `${RESERVATIONS_DIR}/${safe}.lock`;
-	}
-
-	async function acquireLock(
-		filePath: string,
-		reason?: string,
-		ttlSeconds = 600,
-		overrideAgent?: string,
-	): Promise<{ acquired: boolean; holder?: string }> {
-		const lockPath = lockDir(filePath);
-		const now = Date.now();
-		const expires = now + ttlSeconds * 1000;
-		const agentToUse = overrideAgent || state.agentId;
-
-		// Atomic: mkdir fails if dir exists
-		try {
-			await $`mkdir ${lockPath}`.cwd(directory);
-		} catch {
-			// Lock exists - check if expired
-			try {
-				const metaPath = `${lockPath}/meta.json`;
-				const content = await $`cat ${metaPath}`.cwd(directory).text();
-				const lock: LockData = JSON.parse(content);
-
-				if (lock.expires < now) {
-					// Expired - remove and retry
-					await $`rm -rf ${lockPath}`.cwd(directory).quiet();
-					return acquireLock(filePath, reason, ttlSeconds, overrideAgent);
-				}
-
-				if (lock.agent === agentToUse) {
-					// We already hold this lock - refresh it
-					lock.expires = expires;
-					await $`echo ${JSON.stringify(lock)} > ${metaPath}`
-						.cwd(directory)
-						.quiet();
-					return { acquired: true };
-				}
-
-				return { acquired: false, holder: lock.agent };
-			} catch {
-				// Corrupted lock - remove and retry
-				await $`rm -rf ${lockPath}`.cwd(directory).quiet();
-				return acquireLock(filePath, reason, ttlSeconds, overrideAgent);
-			}
-		}
-
-		// Lock acquired - write metadata
-		const lockData: LockData = {
-			path: filePath,
-			agent: agentToUse,
-			reason,
-			created: now,
-			expires,
-			task: state.currentTask,
-		};
-
-		const metaPath = `${lockPath}/meta.json`;
-		await $`echo ${JSON.stringify(lockData)} > ${metaPath}`
-			.cwd(directory)
-			.quiet();
-		state.reservedFiles.add(filePath);
-		return { acquired: true };
-	}
-
-	async function releaseLock(filePath: string): Promise<void> {
-		const lockPath = lockDir(filePath);
-		await $`rm -rf ${lockPath}`
-			.cwd(directory)
-			.quiet()
-			.catch(() => {});
-		state.reservedFiles.delete(filePath);
-	}
-
-	async function getAllLocks(): Promise<LockData[]> {
-		try {
-			const result =
-				await $`find ${RESERVATIONS_DIR} -name "meta.json" -type f 2>/dev/null`
-					.cwd(directory)
-					.text()
-					.catch(() => "");
-
-			if (!result.trim()) return [];
-
-			const locks: LockData[] = [];
-			const now = Date.now();
-
-			for (const metaPath of result.trim().split("\n")) {
-				try {
-					const content = await $`cat ${metaPath}`.cwd(directory).text();
-					const lock: LockData = JSON.parse(content);
-					if (lock.expires > now) {
-						locks.push(lock);
-					}
-				} catch {
-					// Skip invalid
-				}
-			}
-			return locks;
-		} catch {
-			return [];
-		}
-	}
-
-	async function cleanupExpiredLocks(): Promise<number> {
-		let cleaned = 0;
-		try {
-			const result =
-				await $`find ${RESERVATIONS_DIR} -name "meta.json" -type f 2>/dev/null`
-					.cwd(directory)
-					.text()
-					.catch(() => "");
-
-			if (!result.trim()) return 0;
-
-			const now = Date.now();
-			for (const metaPath of result.trim().split("\n")) {
-				try {
-					const content = await $`cat ${metaPath}`.cwd(directory).text();
-					const lock: LockData = JSON.parse(content);
-					if (lock.expires < now) {
-						const lockDir = metaPath.replace("/meta.json", "");
-						await $`rm -rf ${lockDir}`.cwd(directory).quiet();
-						cleaned++;
-					}
-				} catch {
-					// Remove corrupted lock
-					const lockDir = metaPath.replace("/meta.json", "");
-					await $`rm -rf ${lockDir}`.cwd(directory).quiet();
-					cleaned++;
-				}
-			}
-		} catch {
-			// Ignore
-		}
-		return cleaned;
-	}
-
-	// =============================================================================
-	// Message Helpers
-	// =============================================================================
-
-	async function ensureReservationsDir(): Promise<void> {
-		await $`mkdir -p ${RESERVATIONS_DIR}`.cwd(directory).quiet();
-	}
-
-	async function appendMessage(msg: Message): Promise<void> {
-		await ensureReservationsDir();
-		await $`echo ${JSON.stringify(msg)} >> ${RESERVATIONS_DIR}/messages.jsonl`
-			.cwd(directory)
-			.quiet();
-	}
-
-	async function readMessages(
-		limit: number,
-		unreadOnly: boolean,
-	): Promise<Message[]> {
-		try {
-			const content =
-				await $`cat ${RESERVATIONS_DIR}/messages.jsonl 2>/dev/null`
-					.cwd(directory)
-					.text();
-
-			if (!content.trim()) return [];
-
-			let msgs: Message[] = content
-				.trim()
-				.split("\n")
-				.map((line) => {
-					try {
-						return JSON.parse(line) as Message;
-					} catch {
-						return null;
-					}
-				})
-				.filter((m): m is Message => m !== null)
-				.filter((m) => m.to === "all" || m.to === state.agentId);
-
-			if (unreadOnly) msgs = msgs.filter((m) => !m.read);
-			return msgs.slice(-limit).reverse();
-		} catch {
-			return [];
-		}
-	}
-
-	async function cleanupOldMessages(maxAgeDays: number): Promise<number> {
-		try {
-			const content =
-				await $`cat ${RESERVATIONS_DIR}/messages.jsonl 2>/dev/null`
-					.cwd(directory)
-					.text();
-
-			if (!content.trim()) return 0;
-
-			const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
-			const msgs = content
-				.trim()
-				.split("\n")
-				.map((line) => {
-					try {
-						return JSON.parse(line) as Message;
-					} catch {
-						return null;
-					}
-				})
-				.filter((m): m is Message => m !== null && m.at > cutoff);
-
-			const originalCount = content.trim().split("\n").length;
-			const newContent = msgs.map((m) => JSON.stringify(m)).join("\n");
-			await $`echo ${newContent} > ${RESERVATIONS_DIR}/messages.jsonl`
-				.cwd(directory)
-				.quiet();
-
-			return originalCount - msgs.length;
-		} catch {
-			return 0;
-		}
-	}
-
-	// =============================================================================
-	// JSON Response Helper
-	// =============================================================================
-
-	function json(data: Record<string, unknown>): string {
-		return JSON.stringify(data, null, 0);
-	}
-
-	// =============================================================================
-	// Tools
-	// =============================================================================
-
-	return {
-		tool: {
-			bd_init: tool({
-				description: "Join beads workspace. MUST call first.",
-				args: {
-					team: tool.schema.string().optional().describe("Team name"),
-					role: tool.schema
-						.string()
-						.optional()
-						.describe("Role: build|rush|explore|planner|review|scout|vision"),
-				},
-				async execute(args) {
-					await $`bd init`
-						.cwd(directory)
-						.quiet()
-						.catch(() => {});
-					await ensureReservationsDir();
-
-					state.team = args.team || "default";
-					state.role = args.role || "";
-					state.initialized = true;
-					state.currentTask = null;
-					state.reservedFiles.clear();
-
-					// Cleanup expired locks on init
-					const cleaned = await cleanupExpiredLocks();
-
-					return json({
-						ok: 1,
-						agent: state.agentId,
-						ws: directory,
-						team: state.team,
-						role: state.role || undefined,
-						cleaned_locks: cleaned || undefined,
-					});
-				},
-			}),
-
-			bd_claim: tool({
-				description: "Claim next ready task. Auto-syncs, marks in_progress.",
-				args: {},
-				async execute() {
-					if (!state.initialized)
-						return json({ error: "Call bd_init() first" });
-
-					await bdSync();
-					const { tasks, error } = await bdReady();
-					if (error) return json({ error });
-					if (!tasks.length) return json({ msg: "no ready tasks" });
-
-					let task = tasks[0];
-					if (state.role) {
-						const roleTask = tasks.find((t) => t.tags?.includes(state.role));
-						if (roleTask) task = roleTask;
-					}
-
-					const updateResult = await bdUpdate(task.id, {
-						status: "in_progress",
-					});
-					if (updateResult.error) return json({ error: updateResult.error });
-
-					state.currentTask = task.id;
-
-					return json({
-						id: task.id,
-						t: task.title,
-						p: task.priority,
-						type: task.type,
-					});
-				},
-			}),
-
-			bd_done: tool({
-				description:
-					"Complete task. Auto-releases files, syncs. Restart session after.",
-				args: {
-					id: tool.schema.string().describe("Task ID"),
-					msg: tool.schema
-						.string()
-						.default("completed")
-						.describe("Completion message"),
-				},
-				async execute(args, context) {
-					const taskId = args.id || state.currentTask;
-					if (!taskId) return json({ error: "No task ID" });
-
-					// Audit trail
-					const auditAgent = context?.agent || state.agentId;
-
-					const closeResult = await bdClose(
-						taskId,
-						`${args.msg} [by ${auditAgent}]`,
-					);
-					if (closeResult.error) return json({ error: closeResult.error });
-
-					// Release all locks
-					for (const path of state.reservedFiles) {
-						await releaseLock(path);
-					}
-
-					await bdSync();
-					state.currentTask = null;
-
-					return json({ ok: 1, closed: taskId, hint: "Restart session" });
-				},
-			}),
-
-			bd_add: tool({
-				description: "Create issue. Use tags to assign to roles.",
-				args: {
-					title: tool.schema.string().describe("Actionable title"),
-					desc: tool.schema
-						.string()
-						.optional()
-						.describe("Why/what/how context"),
-					pri: tool.schema
-						.number()
-						.default(2)
-						.describe("0=critical,1=high,2=normal,3=low,4=backlog"),
-					type: tool.schema
-						.string()
-						.default("task")
-						.describe("task|bug|feature|epic|chore"),
-					tags: tool.schema
-						.array(tool.schema.string())
-						.optional()
-						.describe(
-							"Agent tags: build,rush,explore,planner,review,scout,vision",
-						),
-					parent: tool.schema.string().optional().describe("Parent issue ID"),
-					deps: tool.schema
-						.array(tool.schema.string())
-						.optional()
-						.describe("Dependencies (type:id format)"),
-					assignee: tool.schema.string().optional().describe("Assignee name"),
-					estimate: tool.schema
-						.number()
-						.optional()
-						.describe("Time estimate in minutes (e.g. 60 for 1h)"),
-					acceptance: tool.schema
-						.string()
-						.optional()
-						.describe("Acceptance criteria"),
-				},
-				async execute(args) {
-					if (!args.title) return json({ error: "title required" });
-
-					const result = await bdCreate(args.title, {
-						priority: args.pri,
-						type: args.type,
-						description: args.desc,
-						parent: args.parent,
-						tags: args.tags,
-						deps: args.deps,
-						assignee: args.assignee,
-						estimate: args.estimate,
-						acceptance: args.acceptance,
-					});
-
-					if (result.error) return json({ error: result.error });
-
-					return json({
-						id: result.id,
-						t: args.title,
-						p: args.pri || 2,
-					});
-				},
-			}),
-
-			bd_assign: tool({
-				description:
-					"Assign task to role (leader only). Adds tag and notifies.",
-				args: {
-					id: tool.schema.string().describe("Issue ID"),
-					role: tool.schema
-						.string()
-						.describe("Role: build|rush|explore|planner|review|scout|vision"),
-					notify: tool.schema
-						.boolean()
-						.default(true)
-						.describe("Broadcast notification"),
-				},
-				async execute(args) {
-					if (!args.id || !args.role)
-						return json({ error: "id and role required" });
-
-					const result = await bdUpdate(args.id, { addLabel: args.role });
-					if (result.error) return json({ error: result.error });
-
-					if (args.notify !== false) {
-						await appendMessage({
-							id: `notify-${Date.now().toString(36)}`,
-							from: state.agentId,
-							to: "all",
-							subj: `Task ${args.id} assigned to ${args.role}`,
-							importance: "normal",
-							at: Date.now(),
-							read: false,
-						});
-					}
-
-					return json({ ok: 1, id: args.id, role: args.role });
-				},
-			}),
-
-			bd_ls: tool({
-				description: "List issues. status: open|closed|in_progress|ready|all",
-				args: {
-					status: tool.schema.string().default("open"),
-					limit: tool.schema.number().default(10),
-					offset: tool.schema.number().default(0),
-					sort: tool.schema
-						.string()
-						.optional()
-						.describe("Sort by: priority|created|updated|title"),
-					reverse: tool.schema
-						.boolean()
-						.optional()
-						.describe("Reverse sort order"),
-					label: tool.schema.string().optional().describe("Filter by label"),
-					assignee: tool.schema
-						.string()
-						.optional()
-						.describe("Filter by assignee"),
-					type: tool.schema
-						.string()
-						.optional()
-						.describe("Filter by type: task|bug|feature|epic"),
-					priorityMin: tool.schema
-						.number()
-						.optional()
-						.describe("Min priority (0-4)"),
-					priorityMax: tool.schema
-						.number()
-						.optional()
-						.describe("Max priority (0-4)"),
-				},
-				async execute(args) {
-					const status = args.status || "open";
-					const limit = Math.min(args.limit || 10, 50);
-					const offset = args.offset || 0;
-
-					const opts = {
-						status: status === "all" ? undefined : status,
-						sort: args.sort,
-						reverse: args.reverse,
-						label: args.label,
-						assignee: args.assignee,
-						type: args.type,
-						priorityMin: args.priorityMin,
-						priorityMax: args.priorityMax,
-					};
-
-					const result =
-						status === "ready"
-							? await bdReady({
-									sort: args.sort,
-									limit,
-									assignee: args.assignee,
-									label: args.label,
-								})
-							: await bdList(opts);
-
-					if (result.error) return json({ error: result.error });
-
-					const items = result.tasks.slice(offset, offset + limit).map((t) => ({
-						id: t.id,
-						t: t.title,
-						p: t.priority,
-						s: t.status,
-						tags: t.tags?.length ? t.tags : undefined,
-					}));
-
-					return json({
-						items,
-						count: items.length,
-						total: result.tasks.length,
-					});
-				},
-			}),
-
-			bd_show: tool({
-				description: "Get full issue details.",
-				args: { id: tool.schema.string().describe("Issue ID") },
-				async execute(args) {
-					if (!args.id) return json({ error: "id required" });
-					const result = await bdShow(args.id);
-					if (result.error) return json({ error: result.error });
-					return json(result.task as unknown as Record<string, unknown>);
-				},
-			}),
-
-			bd_reserve: tool({
-				description: "Lock files for editing. Prevents conflicts.",
-				args: {
-					paths: tool.schema
-						.array(tool.schema.string())
-						.describe("Files to lock"),
-					reason: tool.schema.string().optional().describe("Why reserving"),
-					ttl: tool.schema
-						.number()
-						.default(600)
-						.describe("Seconds until expiry"),
-				},
-				async execute(args, context) {
-					if (!args.paths?.length) return json({ error: "paths required" });
-
-					// Log who is reserving for audit
-					const reservingAgent = context?.agent || state.agentId;
-
-					await ensureReservationsDir();
-
-					const granted: string[] = [];
-					const conflicts: { path: string; holder?: string }[] = [];
-
-					for (const path of args.paths) {
-						const result = await acquireLock(
-							path,
-							args.reason,
-							args.ttl,
-							reservingAgent,
-						);
-						if (result.acquired) {
-							granted.push(path);
-						} else {
-							conflicts.push({ path, holder: result.holder });
-						}
-					}
-
-					const response: Record<string, unknown> = { granted };
-					if (conflicts.length) response.conflicts = conflicts;
-					return json(response);
-				},
-			}),
-
-			bd_release: tool({
-				description: "Unlock files. Auto-released on done().",
-				args: {
-					paths: tool.schema
-						.array(tool.schema.string())
-						.optional()
-						.describe("Files to unlock (empty=all)"),
-				},
-				async execute(args) {
-					const toRelease = args.paths?.length
-						? args.paths
-						: [...state.reservedFiles];
-
-					for (const path of toRelease) {
-						await releaseLock(path);
-					}
-
-					return json({ released: toRelease });
-				},
-			}),
-
-			bd_reservations: tool({
-				description: "List active file locks. Check before editing.",
-				args: {},
-				async execute() {
-					const locks = await getAllLocks();
-					return json({
-						locks: locks.map((r) => ({
-							path: r.path,
-							agent: r.agent,
-							expires: new Date(r.expires).toISOString(),
-							task: r.task,
-						})),
-						count: locks.length,
-					});
-				},
-			}),
-
-			bd_msg: tool({
-				description:
-					"Send message. Use global=true + to='all' for team-wide broadcast.",
-				args: {
-					subj: tool.schema.string().describe("Subject"),
-					body: tool.schema.string().optional().describe("Message body"),
-					to: tool.schema
-						.string()
-						.default("all")
-						.describe("Recipient or 'all'"),
-					importance: tool.schema
-						.string()
-						.default("normal")
-						.describe("low|normal|high"),
-					thread: tool.schema.string().optional().describe("Thread ID"),
-					global: tool.schema
-						.boolean()
-						.default(false)
-						.describe("Send to all workspaces"),
-				},
-				async execute(args, context) {
-					if (!args.subj) return json({ error: "subj required" });
-
-					// Use context agent if available for audit trail
-					const senderAgent = context?.agent || state.agentId;
-
-					const msg: Message = {
-						id: `msg-${Date.now().toString(36)}`,
-						from: senderAgent,
-						to: args.to || "all",
-						subj: args.subj,
-						body: args.body,
-						importance: args.importance || "normal",
-						thread: args.thread,
-						global: args.global,
-						at: Date.now(),
-						read: false,
-					};
-
-					await appendMessage(msg);
-					return json({ ok: 1, id: msg.id });
-				},
-			}),
-
-			bd_inbox: tool({
-				description: "Get messages. Includes global by default.",
-				args: {
-					n: tool.schema.number().default(5).describe("Max messages"),
-					unread: tool.schema.boolean().default(false).describe("Unread only"),
-					global: tool.schema
-						.boolean()
-						.default(true)
-						.describe("Include cross-workspace"),
-				},
-				async execute(args) {
-					const msgs = await readMessages(args.n || 5, args.unread || false);
-					return json({ msgs, count: msgs.length });
-				},
-			}),
-
-			bd_ack: tool({
-				description: "Acknowledge message(s). Marks as read.",
-				args: {
-					ids: tool.schema
-						.array(tool.schema.string())
-						.describe("Message IDs to acknowledge"),
-				},
-				async execute(args) {
-					if (!args.ids?.length) return json({ error: "ids required" });
-
-					try {
-						const content =
-							await $`cat ${RESERVATIONS_DIR}/messages.jsonl 2>/dev/null`
-								.cwd(directory)
-								.text();
-
-						if (!content.trim()) return json({ acked: 0 });
-
-						const idsToAck = new Set(args.ids);
-						let acked = 0;
-
-						const msgs = content
-							.trim()
-							.split("\n")
-							.map((line) => {
-								try {
-									const msg = JSON.parse(line) as Message;
-									if (idsToAck.has(msg.id) && !msg.read) {
-										msg.read = true;
-										acked++;
-									}
-									return msg;
-								} catch {
-									return null;
-								}
-							})
-							.filter((m): m is Message => m !== null);
-
-						const newContent = msgs.map((m) => JSON.stringify(m)).join("\n");
-						await $`echo ${newContent} > ${RESERVATIONS_DIR}/messages.jsonl`
-							.cwd(directory)
-							.quiet();
-
-						return json({ ok: 1, acked });
-					} catch {
-						return json({ acked: 0 });
-					}
-				},
-			}),
-
-			bd_whois: tool({
-				description: "Agent directory lookup. See who's working on what.",
-				args: {
-					agent: tool.schema
-						.string()
-						.optional()
-						.describe("Agent ID to lookup (empty=all)"),
-				},
-				async execute(args) {
-					const locks = await getAllLocks();
-					const { tasks: inProgressTasks } = await bdList({
-						status: "in_progress",
-					});
-
-					// Build agent activity map
-					const agentMap: Record<
-						string,
-						{
-							files: string[];
-							task?: string;
-							role?: string;
-						}
-					> = {};
-
-					// Add locks info
-					for (const lock of locks) {
-						if (!agentMap[lock.agent]) {
-							agentMap[lock.agent] = { files: [] };
-						}
-						agentMap[lock.agent].files.push(lock.path);
-						if (lock.task) {
-							agentMap[lock.agent].task = lock.task;
-						}
-					}
-
-					// Add current agent info
-					if (!agentMap[state.agentId]) {
-						agentMap[state.agentId] = { files: [] };
-					}
-					agentMap[state.agentId].role = state.role || undefined;
-					if (state.currentTask) {
-						agentMap[state.agentId].task = state.currentTask;
-					}
-
-					// Filter if specific agent requested
-					if (args.agent) {
-						const agent = agentMap[args.agent];
-						if (!agent) return json({ error: "agent not found" });
-						return json({ agent: args.agent, ...agent });
-					}
-
-					return json({
-						agents: Object.entries(agentMap).map(([id, info]) => ({
-							id,
-							...info,
-						})),
-						in_progress_tasks: inProgressTasks.length,
-					});
-				},
-			}),
-
-			bd_status: tool({
-				description: "Workspace overview. Shows agents, tasks, locks.",
-				args: {
-					include_agents: tool.schema
-						.boolean()
-						.default(false)
-						.describe("Include agent info"),
-				},
-				async execute(args) {
-					const [ready, inProgress, locks] = await Promise.all([
-						bdReady(),
-						bdList({ status: "in_progress" }),
-						getAllLocks(),
-					]);
-
-					const result: Record<string, unknown> = {
-						ws: directory,
-						team: state.team,
-						current_task: state.currentTask,
-						ready: ready.tasks.length,
-						in_progress: inProgress.tasks.length,
-						locks: locks.length,
-					};
-
-					if (args.include_agents) {
-						result.agent = {
-							id: state.agentId,
-							role: state.role || undefined,
-							reserved: [...state.reservedFiles],
-						};
-					}
-
-					return json(result);
-				},
-			}),
-
-			bd_sync: tool({
-				description: "Sync with git. Pull/push changes.",
-				args: {
-					reason: tool.schema
-						.string()
-						.optional()
-						.describe("Audit trail reason for sync"),
-				},
-				async execute(args, context) {
-					const result = await bdSync();
-					// Log sync with context for audit trail
-					const syncAgent = context?.agent || state.agentId;
-					return json({
-						ok: 1,
-						output: result.output,
-						by: syncAgent,
-						reason: args.reason,
-					});
-				},
-			}),
-
-			bd_cleanup: tool({
-				description: "Remove old closed issues. Run every few days.",
-				args: {
-					days: tool.schema
-						.number()
-						.default(2)
-						.describe("Delete closed >N days"),
-				},
-				async execute(args) {
-					const result = await bdCleanup(args.days || 2);
-					return json({ ok: 1, output: result.output });
-				},
-			}),
-
-			bd_doctor: tool({
-				description: "Check/repair database health.",
-				args: {},
-				async execute() {
-					const result = await bdDoctor();
-					return json({ ok: 1, output: result.output });
-				},
-			}),
-
-			bd_dep: tool({
-				description: "Manage dependencies. action: add|remove|tree",
-				args: {
-					action: tool.schema.string().describe("add|remove|tree"),
-					child: tool.schema.string().describe("Child issue ID"),
-					parent: tool.schema
-						.string()
-						.optional()
-						.describe("Parent issue ID (for add/remove)"),
-					type: tool.schema
-						.string()
-						.default("blocks")
-						.describe("Dependency type: blocks|related|parent"),
-				},
-				async execute(args) {
-					if (!args.action || !args.child)
-						return json({ error: "action and child required" });
-
-					if (args.action === "tree") {
-						const result = await bdDepTree(args.child);
-						if (result.error) return json({ error: result.error });
-						return json({ tree: result.output });
-					}
-
-					if (!args.parent)
-						return json({ error: "parent required for add/remove" });
-
-					if (args.action === "add") {
-						const result = await bdDepAdd(args.child, args.parent, args.type);
-						if (result.error) return json({ error: result.error });
-						return json({
-							ok: 1,
-							child: args.child,
-							parent: args.parent,
-							type: args.type,
-						});
-					}
-
-					if (args.action === "remove") {
-						const result = await bdDepRemove(args.child, args.parent);
-						if (result.error) return json({ error: result.error });
-						return json({
-							ok: 1,
-							removed: { child: args.child, parent: args.parent },
-						});
-					}
-
-					return json({ error: "action must be add|remove|tree" });
-				},
-			}),
-
-			bd_blocked: tool({
-				description: "Show blocked issues (have unresolved dependencies).",
-				args: {},
-				async execute() {
-					const { tasks, error } = await bdBlocked();
-					if (error) return json({ error });
-
-					return json({
-						items: tasks.map((t) => ({
-							id: t.id,
-							t: t.title,
-							p: t.priority,
-						})),
-						count: tasks.length,
-					});
-				},
-			}),
-
-			bd_reopen: tool({
-				description: "Reopen a closed issue.",
-				args: {
-					id: tool.schema.string().describe("Issue ID to reopen"),
-				},
-				async execute(args) {
-					if (!args.id) return json({ error: "id required" });
-
-					const result = await bdReopen(args.id);
-					if (result.error) return json({ error: result.error });
-
-					return json({ ok: 1, reopened: args.id });
-				},
-			}),
-
-			bd_update: tool({
-				description:
-					"Update issue properties (title, status, priority, assignee, dependencies).",
-				args: {
-					id: tool.schema.string().describe("Issue ID to update"),
-					title: tool.schema.string().optional().describe("New title"),
-					status: tool.schema.string().optional().describe("New status"),
-					priority: tool.schema
-						.number()
-						.optional()
-						.describe("New priority (0-4)"),
-					assignee: tool.schema
-						.string()
-						.optional()
-						.describe("Assign to user/role"),
-					removeDep: tool.schema
-						.string()
-						.optional()
-						.describe("Remove dependency"),
-					addDep: tool.schema.string().optional().describe("Add dependency"),
-				},
-				async execute(args) {
-					if (!args.id) return json({ error: "id required" });
-
-					const result = await bdUpdate(args.id, {
-						title: args.title,
-						status: args.status,
-						priority: args.priority,
-						assignee: args.assignee,
-						removeDep: args.removeDep,
-						addDep: args.addDep,
-					});
-					if (result.error) return json({ error: result.error });
-
-					return json({ ok: 1, updated: args.id });
-				},
-			}),
-
-			bd_ready: tool({
-				description: "List ready-to-work tasks (no unresolved dependencies).",
-				args: {
-					sort: tool.schema.string().optional().describe("Sort field"),
-					limit: tool.schema.number().optional().describe("Max results"),
-					assignee: tool.schema
-						.string()
-						.optional()
-						.describe("Filter by assignee"),
-					label: tool.schema.string().optional().describe("Filter by label"),
-				},
-				async execute(args) {
-					const result = await bdReady({
-						sort: args.sort,
-						limit: args.limit,
-						assignee: args.assignee,
-						label: args.label,
-					});
-					if (result.error) return json({ error: result.error });
-
-					return json({
-						items: result.tasks.map((t: Task) => ({
-							id: t.id,
-							title: t.title,
-							priority: t.priority,
-						})),
-						count: result.tasks.length,
-					});
-				},
-			}),
-
-			bd_search: tool({
-				description: "Search issues by text query.",
-				args: {
-					query: tool.schema.string().describe("Search text"),
-				},
-				async execute(args) {
-					if (!args.query) return json({ error: "query required" });
-
-					const { tasks, error } = await bdSearch(args.query);
-					if (error) return json({ error });
-
-					return json({
-						items: tasks.map((t) => ({
-							id: t.id,
-							t: t.title,
-							p: t.priority,
-							s: t.status,
-						})),
-						count: tasks.length,
-					});
-				},
-			}),
-		},
-
-		event: async ({ event }) => {
-			if (event.type === "session.idle" && state.currentTask) {
-				await bdSync();
-			}
-
-			// Cleanup expired locks on compaction
-			if (event.type === "session.compacted") {
-				await cleanupExpiredLocks();
-			}
-
-			// Log errors to audit trail
-			if (event.type === "session.error" && state.currentTask) {
-				await appendMessage({
-					id: `err-${Date.now().toString(36)}`,
-					from: state.agentId,
-					to: "all",
-					subj: `Session error on task ${state.currentTask}`,
-					body: `Error occurred during task execution`,
-					importance: "high",
-					at: Date.now(),
-					read: false,
-				});
-			}
-		},
-	};
-};