opencodekit 0.15.19 → 0.15.21

package/dist/template/.opencode/{tools → tool}/swarm-monitor.ts

@@ -2,7 +2,6 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { tool } from "@opencode-ai/plugin";
 
-const SWARM_MAIL_FILE = ".beads/swarm-mail.jsonl";
 const PROGRESS_FILE = ".beads/swarm-progress.jsonl";
 
 interface ProgressEntry {
@@ -16,37 +15,26 @@ interface ProgressEntry {
 	file?: string;
 }
 
-interface MailEntry {
-	timestamp: string;
-	team_name: string;
-	from_worker?: string;
-	to_worker?: string;
-	message?: string;
-	status?: string;
-}
-
 export default tool({
-	description: `Swarm monitoring and coordination - combines mailbox and progress tracking.
+	description: `Swarm progress tracking for parallel task visualization.
 
 Operations:
-- mail_send: Send message to team mailbox
-- mail_read: Read messages from team mailbox
 - progress_update: Update worker progress
 - progress_render: Display ASCII progress UI
 - render_block: Display beautiful markdown block UI for TUI
-- status: Get full team status (mail + progress)
+- status: Get full team status
 - clear: Clear team data
 
-Usage (use the actual team name from swarm-plan):
-  swarm-monitor({ operation: "mail_send", team_name: "<team-name>", from_worker: "worker-1", message: "DONE: <actual work completed>" })
+Note: For worker communication, use the Task tool which handles results directly.
+
+Usage:
   swarm-monitor({ operation: "progress_update", team_name: "<team-name>", worker_id: "worker-1", phase: "<phase>", progress: <0-100>, status: "working", file: "<current file>" })
-  swarm-monitor({ operation: "render_block", team_name: "<team-name>" })`,
+  swarm-monitor({ operation: "render_block", team_name: "<team-name>" })
+  swarm-monitor({ operation: "status", team_name: "<team-name>" })`,
 
 	args: {
 		operation: tool.schema
 			.enum([
-				"mail_send",
-				"mail_read",
 				"progress_update",
 				"progress_render",
 				"status",
@@ -55,18 +43,6 @@ Usage (use the actual team name from swarm-plan):
 			])
 			.describe("Monitoring operation to perform"),
 		team_name: tool.schema.string().describe("Team/swarm identifier"),
-		from_worker: tool.schema
-			.string()
-			.optional()
-			.describe("Sending worker (for mail_send)"),
-		to_worker: tool.schema
-			.string()
-			.optional()
-			.describe("Target worker (for mail_send)"),
-		message: tool.schema
-			.string()
-			.optional()
-			.describe("Message content (for mail_send)"),
 		worker_id: tool.schema
 			.string()
 			.optional()
@@ -85,30 +61,20 @@ Usage (use the actual team name from swarm-plan):
 			.enum(["idle", "working", "completed", "error", "blocked"])
 			.optional()
 			.describe("Worker status (for progress_update)"),
+		message: tool.schema
+			.string()
+			.optional()
+			.describe("Status message (for progress_update)"),
 		file: tool.schema
 			.string()
 			.optional()
 			.describe("Current file being worked on"),
-		limit: tool.schema
-			.number()
-			.optional()
-			.describe("Limit entries (for mail_read)"),
 	},
 
 	execute: async (args, ctx) => {
 		const worktree = ctx.worktree || process.cwd();
 
 		switch (args.operation) {
-			case "mail_send":
-				return await sendMail(
-					args.team_name,
-					args.from_worker,
-					args.to_worker,
-					args.message || "",
-					worktree,
-				);
-			case "mail_read":
-				return await readMail(args.team_name, args.limit, worktree);
 			case "progress_update":
 				return await updateProgress(
 					{
@@ -137,83 +103,6 @@ Usage (use the actual team name from swarm-plan):
 	},
 });
 
-// Mail operations
-async function sendMail(
-	teamName: string,
-	fromWorker: string | undefined,
-	toWorker: string | undefined,
-	message: string,
-	worktree: string,
-): Promise<string> {
-	if (!teamName || !message) {
-		return "Error: team_name and message are required.";
-	}
-
-	const mailPath = path.join(worktree, SWARM_MAIL_FILE);
-	const entry = {
-		timestamp: new Date().toISOString(),
-		team_name: teamName,
-		from_worker: fromWorker || "system",
-		to_worker: toWorker || "all",
-		message,
-		status: "unread",
-	};
-
-	try {
-		await fs.mkdir(path.dirname(mailPath), { recursive: true });
-		await fs.appendFile(mailPath, `${JSON.stringify(entry)}\n`, "utf-8");
-		return JSON.stringify(
-			{
-				success: true,
-				team_name: teamName,
-				from_worker: fromWorker,
-				to_worker: toWorker,
-				message,
-				mail_file: SWARM_MAIL_FILE,
-			},
-			null,
-			2,
-		);
-	} catch (error: any) {
-		return `Error: Failed to write to ${SWARM_MAIL_FILE}: ${error}`;
-	}
-}
-
-async function readMail(
-	teamName: string,
-	limit: number | undefined,
-	worktree: string,
-): Promise<string> {
-	if (!teamName) {
-		return "Error: team_name is required.";
-	}
-
-	const mailPath = path.join(worktree, SWARM_MAIL_FILE);
-
-	try {
-		const content = await fs.readFile(mailPath, "utf-8");
-		const lines = content.trim().split("\n").filter(Boolean);
-		const entries = lines
-			.map((line) => {
-				try {
-					return JSON.parse(line) as MailEntry;
-				} catch {
-					return null;
-				}
-			})
-			.filter((e): e is MailEntry => e !== null);
-
-		const relevant = entries.filter((m) => m.team_name === teamName);
-
-		if (limit && limit > 0) {
-			return JSON.stringify(relevant.slice(-limit), null, 2);
-		}
-		return JSON.stringify(relevant, null, 2);
-	} catch {
-		return JSON.stringify([], null, 2);
-	}
-}
-
 // Progress operations
 async function updateProgress(
 	entry: ProgressEntry,
@@ -351,11 +240,9 @@ async function renderBlock(
 	worktree: string,
 ): Promise<string> {
 	const { workers } = await getProgress(teamName, worktree);
-	const mailData = await readMail(teamName, 5, worktree);
-	const messages = JSON.parse(mailData);
 
-	if (workers.length === 0 && messages.length === 0) {
-		return `## 🐝 Swarm: ${teamName}\n\n_No active workers or messages._`;
+	if (workers.length === 0) {
+		return `## 🐝 Swarm: ${teamName}\n\n_No active workers._`;
 	}
 
 	// Group workers by phase
@@ -386,7 +273,6 @@ async function renderBlock(
 	lines.push(`| ✅ Completed | ${completed} |`);
 	lines.push(`| ▶️ Working | ${working} |`);
 	if (errors > 0) lines.push(`| ❌ Errors | ${errors} |`);
-	lines.push(`| 💬 Messages | ${messages.length} |`);
 	lines.push("");
 
 	// Phase details
@@ -430,20 +316,6 @@ async function renderBlock(
 		}
 	}
 
-	// Recent messages
-	if (messages.length > 0) {
-		lines.push("### 💬 Recent Messages");
-		lines.push("");
-
-		for (const msg of messages.slice(-3)) {
-			const time = new Date(msg.timestamp).toLocaleTimeString();
-			const from = msg.from_worker || "system";
-			lines.push(`**${from}** at ${time}:`);
-			lines.push(`> ${msg.message}`);
-			lines.push("");
-		}
-	}
-
 	return lines.join("\n");
 }
 
@@ -452,12 +324,7 @@ async function getFullStatus(
 	teamName: string,
 	worktree: string,
 ): Promise<string> {
-	const [mailData, progressData] = await Promise.all([
-		readMail(teamName, 20, worktree),
-		getProgress(teamName, worktree),
-	]);
-
-	const messages = JSON.parse(mailData);
+	const progressData = await getProgress(teamName, worktree);
 	const { workers } = progressData;
 
 	// Calculate overall stats
@@ -475,10 +342,8 @@ async function getFullStatus(
 				completed: completedWorkers,
 				working: workingWorkers,
 				errors: errorWorkers,
-				messages: messages.length,
 			},
 			workers,
-			messages: messages.slice(-5), // Last 5 messages
 		},
 		null,
 		2,
@@ -487,30 +352,10 @@ async function getFullStatus(
 
 // Clear operations
 async function clearTeam(teamName: string, worktree: string): Promise<string> {
-	const mailPath = path.join(worktree, SWARM_MAIL_FILE);
 	const progressPath = path.join(worktree, PROGRESS_FILE);
 
-	let clearedMail = 0;
 	let clearedProgress = 0;
 
-	// Clear mail entries
-	try {
-		const content = await fs.readFile(mailPath, "utf-8");
-		const lines = content.trim().split("\n").filter(Boolean);
-		const entries = lines.map((line) => JSON.parse(line) as MailEntry);
-		const otherEntries = entries.filter((e) => e.team_name !== teamName);
-		clearedMail = entries.length - otherEntries.length;
-
-		await fs.writeFile(
-			mailPath,
-			otherEntries.map((e) => JSON.stringify(e)).join("\n") +
-				(otherEntries.length > 0 ? "\n" : ""),
-			"utf-8",
-		);
-	} catch {
-		// File doesn't exist
-	}
-
 	// Clear progress entries
 	try {
 		const content = await fs.readFile(progressPath, "utf-8");
@@ -534,7 +379,6 @@ async function clearTeam(teamName: string, worktree: string): Promise<string> {
 			success: true,
 			team_name: teamName,
 			cleared: {
-				mail_entries: clearedMail,
 				progress_entries: clearedProgress,
 			},
 		},

package/dist/template/.opencode/{tools → tool}/swarm-plan.ts

@@ -7,6 +7,25 @@ interface Phase {
 	dependencies: string[];
 }
 
+interface TaskNode {
+	id: string;
+	content: string;
+	phase: string;
+	worker: string;
+	status: "pending" | "in_progress" | "completed";
+	priority: "high" | "medium" | "low";
+	blockedBy: string[];
+	blocks: string[];
+	assignedFiles: string[];
+}
+
+interface DependencyGraph {
+	nodes: TaskNode[];
+	edges: Array<{ from: string; to: string; type: "blocks" | "blocked_by" }>;
+	critical_path: string[];
+	parallelizable_groups: string[][];
+}
+
 interface TaskClassification {
 	type: "search" | "batch" | "writing" | "sequential" | "mixed";
 	coupling: "high" | "medium" | "low";
@@ -33,6 +52,7 @@ interface OrchestrationPlan {
 		max_agents: number;
 		strategy: string;
 	};
+	dependency_graph: DependencyGraph;
 	recommendation: string;
 }
 
@@ -49,7 +69,15 @@ Operations:
 
 Usage (pass the user's actual request):
   swarm-plan({ operation: "analyze", task: "<user's request>", files: "<detected files>" })
-  swarm-plan({ operation: "check", task: "<user's request>", files: "<file count>", recommended_agents: <current> })`,
+  swarm-plan({ operation: "check", task: "<user's request>", files: "<file count>", recommended_agents: <current> })
+
+Worker skills (load these in worker prompt):
+  skill({ name: "verification-before-completion" })  // Required: verify before claiming done
+  skill({ name: "test-driven-development" })         // Recommended: test first, implement, verify
+  skill({ name: "tool-priority" })                   // Recommended: LSP before edits
+
+Worker progress reporting (simplified flow - Task tool returns results directly):
+  swarm-monitor({ operation: "progress_update", team_name: "<team>", worker_id: "<id>", phase: "<phase>", progress: 0-100, status: "working|completed|error", file: "<current-file>" })`,
 
 	args: {
 		operation: tool.schema
@@ -112,6 +140,13 @@ async function analyzeOperation(task: string, files?: string): Promise<string> {
 	// Get allocation strategy
 	const allocation = calculateAllocation(fileCount);
 
+	// Build dependency graph
+	const dependencyGraph = buildDependencyGraph(
+		classification.phases,
+		fileList,
+		task,
+	);
+
 	// Build recommendation
 	let recommendation: string;
 	if (collapseCheck.is_serial_collapse) {
@@ -128,6 +163,7 @@ async function analyzeOperation(task: string, files?: string): Promise<string> {
 		classification,
 		serial_collapse_check: collapseCheck,
 		allocation,
+		dependency_graph: dependencyGraph,
 		recommendation,
 	};
 
@@ -464,3 +500,198 @@ function calculateAllocation(fileCount: number) {
 		strategy: "Conservative start, scale based on bottlenecks",
 	};
 }
+
+/**
+ * Build a dependency graph from phases and files
+ * This enables proper DAG-based task scheduling
+ */
+function buildDependencyGraph(
+	phases: Phase[],
+	files: string[],
+	task: string,
+): DependencyGraph {
+	const nodes: TaskNode[] = [];
+	const edges: Array<{
+		from: string;
+		to: string;
+		type: "blocks" | "blocked_by";
+	}> = [];
+
+	// Distribute files across workers in each phase
+	let taskIdCounter = 1;
+
+	for (const phase of phases) {
+		const phaseFiles =
+			phase.name === "explore" || phase.name === "synthesize"
+				? files
+				: distributeFiles(files, phase.agent_count);
+
+		for (let i = 0; i < phase.agent_count; i++) {
+			const workerId = `${phase.name}-worker-${i + 1}`;
+			const taskId = `task-${taskIdCounter++}`;
+
+			// Determine assigned files based on phase type
+			let assignedFiles: string[];
+			if (phase.name === "explore" || phase.name === "synthesize") {
+				// These phases get all files
+				assignedFiles = files;
+			} else {
+				// Other phases get distributed files
+				const distributed = phaseFiles as string[][];
+				assignedFiles = distributed[i] || [];
+			}
+
+			const node: TaskNode = {
+				id: taskId,
+				content: `${phase.name}: ${task.slice(0, 50)}${task.length > 50 ? "..." : ""}`,
+				phase: phase.name,
+				worker: workerId,
+				status: "pending",
+				priority: phase.name === "explore" ? "high" : "medium",
+				blockedBy: [],
+				blocks: [],
+				assignedFiles,
+			};
+
+			// Add dependencies based on phase dependencies
+			if (phase.dependencies.length > 0) {
+				for (const dep of phase.dependencies) {
+					// Find all tasks in the dependency phase
+					const depTasks = nodes.filter((n) => n.phase === dep);
+					for (const depTask of depTasks) {
+						node.blockedBy.push(depTask.id);
+						depTask.blocks.push(taskId);
+						edges.push({ from: depTask.id, to: taskId, type: "blocks" });
+					}
+				}
+			}
+
+			nodes.push(node);
+		}
+	}
+
+	// Calculate critical path (longest chain of dependencies)
+	const criticalPath = calculateCriticalPath(nodes);
+
+	// Find parallelizable groups (tasks that can run simultaneously)
+	const parallelizableGroups = findParallelizableGroups(nodes);
+
+	return {
+		nodes,
+		edges,
+		critical_path: criticalPath,
+		parallelizable_groups: parallelizableGroups,
+	};
+}
+
+/**
+ * Distribute files across workers
+ */
+function distributeFiles(files: string[], workerCount: number): string[][] {
+	if (files.length === 0 || workerCount === 0) return [];
+
+	const result: string[][] = Array.from({ length: workerCount }, () => []);
+
+	files.forEach((file, index) => {
+		result[index % workerCount].push(file);
+	});
+
+	return result;
+}
+
+/**
+ * Calculate the critical path (longest dependency chain)
+ */
+function calculateCriticalPath(nodes: TaskNode[]): string[] {
+	const visited = new Set<string>();
+	const pathLengths = new Map<string, number>();
+	const pathParents = new Map<string, string | null>();
+
+	// Find root nodes (no blockedBy)
+	const roots = nodes.filter((n) => n.blockedBy.length === 0);
+
+	// BFS to calculate distances
+	const queue = [...roots];
+	for (const root of roots) {
+		pathLengths.set(root.id, 1);
+		pathParents.set(root.id, null);
+	}
+
+	while (queue.length > 0) {
+		const current = queue.shift()!;
+		if (visited.has(current.id)) continue;
+		visited.add(current.id);
+
+		const currentLength = pathLengths.get(current.id) || 1;
+
+		for (const blockedId of current.blocks) {
+			const blocked = nodes.find((n) => n.id === blockedId);
+			if (!blocked) continue;
+
+			const newLength = currentLength + 1;
+			const existingLength = pathLengths.get(blockedId) || 0;
+
+			if (newLength > existingLength) {
+				pathLengths.set(blockedId, newLength);
+				pathParents.set(blockedId, current.id);
+			}
+
+			queue.push(blocked);
+		}
+	}
+
+	// Find the node with longest path
+	let maxLength = 0;
+	let maxNode: string | null = null;
+	for (const [nodeId, length] of pathLengths) {
+		if (length > maxLength) {
+			maxLength = length;
+			maxNode = nodeId;
+		}
+	}
+
+	// Reconstruct path
+	const criticalPath: string[] = [];
+	let current = maxNode;
+	while (current) {
+		criticalPath.unshift(current);
+		current = pathParents.get(current) || null;
+	}
+
+	return criticalPath;
+}
+
+/**
+ * Find groups of tasks that can run in parallel
+ */
+function findParallelizableGroups(nodes: TaskNode[]): string[][] {
+	const groups: string[][] = [];
+	const assigned = new Set<string>();
+
+	// Group by "generation" - tasks whose all dependencies are satisfied
+	while (assigned.size < nodes.length) {
+		const group: string[] = [];
+
+		for (const node of nodes) {
+			if (assigned.has(node.id)) continue;
+
+			// Check if all blockedBy are already assigned
+			const allDependenciesMet = node.blockedBy.every((dep) =>
+				assigned.has(dep),
+			);
+
+			if (allDependenciesMet) {
+				group.push(node.id);
+			}
+		}
+
+		if (group.length === 0) break; // Prevent infinite loop on cycles
+
+		for (const id of group) {
+			assigned.add(id);
+		}
+		groups.push(group);
+	}
+
+	return groups;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.15.19",
+	"version": "0.15.21",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"keywords": ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
 	"license": "MIT",
@@ -32,6 +32,8 @@
 		"format:check": "oxfmt --check"
 	},
 	"dependencies": {
+		"@ai-sdk/provider": "^3.0.6",
+		"@ai-sdk/provider-utils": "^4.0.11",
 		"@clack/prompts": "^0.7.0",
 		"@opencode-ai/plugin": "^1.1.12",
 		"@opentui/core": "^0.1.72",