pi-crew 0.1.0

package/src/ui/run-dashboard.ts

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+import type { Component } from "@mariozechner/pi-tui";
+import type { TeamRunManifest } from "../state/types.ts";
+
+export type RunDashboardAction = "status" | "summary" | "artifacts" | "api" | "reload";
+export interface RunDashboardSelection {
+	runId: string;
+	action: RunDashboardAction;
+}
+
+function truncate(value: string, width: number): string {
+	if (width <= 0) return "";
+	if (value.length <= width) return value;
+	if (width <= 1) return "…";
+	return `${value.slice(0, width - 1)}…`;
+}
+
+function statusIcon(status: string): string {
+	if (status === "completed") return "✓";
+	if (status === "failed") return "✗";
+	if (status === "cancelled") return "!";
+	if (status === "running") return "▶";
+	if (status === "blocked") return "■";
+	return "·";
+}
+
+function readProgressPreview(run: TeamRunManifest, maxLines = 5): string[] {
+	const progress = [...run.artifacts].reverse().find((artifact) => artifact.kind === "progress");
+	if (!progress || !fs.existsSync(progress.path)) return ["Progress: (none)"];
+	try {
+		return ["Progress:", ...fs.readFileSync(progress.path, "utf-8").split(/\r?\n/).filter(Boolean).slice(0, maxLines)];
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return [`Progress: failed to read (${message})`];
+	}
+}
+
+function countByStatus(runs: TeamRunManifest[]): string {
+	const counts = new Map<string, number>();
+	for (const run of runs) counts.set(run.status, (counts.get(run.status) ?? 0) + 1);
+	return [...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none";
+}
+
+export class RunDashboard implements Component {
+	private selected = 0;
+	private showFullProgress = false;
+	private readonly runs: TeamRunManifest[];
+	private readonly done: (selection: RunDashboardSelection | undefined) => void;
+
+	constructor(runs: TeamRunManifest[], done: (selection: RunDashboardSelection | undefined) => void) {
+		this.runs = runs;
+		this.done = done;
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const innerWidth = Math.max(20, width - 4);
+		const borderWidth = Math.min(innerWidth, Math.max(0, width - 2));
+		const lines = [
+			`╭${"─".repeat(borderWidth)}╮`,
+			`│ ${truncate("pi-crew dashboard", innerWidth - 1).padEnd(innerWidth - 1)}│`,
+			`│ ${truncate("↑/↓/j/k select • r reload • p progress • s/u/a/i actions • q close", innerWidth - 1).padEnd(innerWidth - 1)}│`,
+			`│ ${truncate(`Runs: ${this.runs.length} • ${countByStatus(this.runs)}`, innerWidth - 1).padEnd(innerWidth - 1)}│`,
+			`├${"─".repeat(borderWidth)}┤`,
+		];
+		if (this.runs.length === 0) {
+			lines.push(`│ ${truncate("No runs found.", innerWidth - 1).padEnd(innerWidth - 1)}│`);
+		} else {
+			for (let i = 0; i < Math.min(this.runs.length, 10); i++) {
+				const run = this.runs[i]!;
+				const marker = i === this.selected ? "›" : " ";
+				const text = `${marker} ${statusIcon(run.status)} ${run.runId} ${run.status} ${run.team}/${run.workflow ?? "none"} ${run.goal}`;
+				lines.push(`│ ${truncate(text, innerWidth - 1).padEnd(innerWidth - 1)}│`);
+			}
+			const selectedRun = this.runs[this.selected];
+			if (selectedRun) {
+				lines.push(`├${"─".repeat(borderWidth)}┤`);
+				const details = [
+					`Selected: ${selectedRun.runId}`,
+					`Status: ${selectedRun.status} | Team: ${selectedRun.team} | Workflow: ${selectedRun.workflow ?? "none"}`,
+					`Created: ${selectedRun.createdAt}`,
+					`Updated: ${selectedRun.updatedAt}`,
+					`Artifacts: ${selectedRun.artifacts.length} | Workspace: ${selectedRun.workspaceMode}`,
+					selectedRun.async ? `Async: pid=${selectedRun.async.pid ?? "unknown"} log=${selectedRun.async.logPath}` : "Async: no",
+					`Goal: ${selectedRun.goal}`,
+				];
+				for (const detail of [...details, ...readProgressPreview(selectedRun, this.showFullProgress ? 20 : 5)]) {
+					lines.push(`│ ${truncate(detail, innerWidth - 1).padEnd(innerWidth - 1)}│`);
+				}
+			}
+		}
+		lines.push(`╰${"─".repeat(borderWidth)}╯`);
+		return lines.map((line) => truncate(line, width));
+	}
+
+	handleInput(data: string): void {
+		if (data === "q" || data === "\u001b") {
+			this.done(undefined);
+			return;
+		}
+		if (data === "\r" || data === "\n" || data === "s") {
+			const runId = this.runs[this.selected]?.runId;
+			this.done(runId ? { runId, action: "status" } : undefined);
+			return;
+		}
+		if (data === "u") {
+			const runId = this.runs[this.selected]?.runId;
+			this.done(runId ? { runId, action: "summary" } : undefined);
+			return;
+		}
+		if (data === "a") {
+			const runId = this.runs[this.selected]?.runId;
+			this.done(runId ? { runId, action: "artifacts" } : undefined);
+			return;
+		}
+		if (data === "i") {
+			const runId = this.runs[this.selected]?.runId;
+			this.done(runId ? { runId, action: "api" } : undefined);
+			return;
+		}
+		if (data === "r") {
+			this.done({ runId: this.runs[this.selected]?.runId ?? "", action: "reload" });
+			return;
+		}
+		if (data === "p") {
+			this.showFullProgress = !this.showFullProgress;
+			return;
+		}
+		if (data === "k" || data === "\u001b[A") {
+			this.selected = Math.max(0, this.selected - 1);
+			return;
+		}
+		if (data === "j" || data === "\u001b[B") {
+			this.selected = Math.min(Math.max(0, this.runs.length - 1), this.selected + 1);
+		}
+	}
+}

package/src/utils/frontmatter.ts

@@ -0,0 +1,36 @@
+export interface ParsedFrontmatter {
+	frontmatter: Record<string, string>;
+	body: string;
+}
+
+export function parseFrontmatter(content: string): ParsedFrontmatter {
+	if (!content.startsWith("---\n") && !content.startsWith("---\r\n")) {
+		return { frontmatter: {}, body: content };
+	}
+
+	const normalized = content.replaceAll("\r\n", "\n");
+	const end = normalized.indexOf("\n---\n", 4);
+	if (end === -1) return { frontmatter: {}, body: content };
+
+	const raw = normalized.slice(4, end);
+	const body = normalized.slice(end + "\n---\n".length);
+	const frontmatter: Record<string, string> = {};
+
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const separator = trimmed.indexOf(":");
+		if (separator === -1) continue;
+		const key = trimmed.slice(0, separator).trim();
+		const value = trimmed.slice(separator + 1).trim();
+		if (key) frontmatter[key] = value;
+	}
+
+	return { frontmatter, body };
+}
+
+export function parseCsv(value: string | undefined): string[] | undefined {
+	if (value === undefined) return undefined;
+	const values = value.split(",").map((item) => item.trim()).filter(Boolean);
+	return values.length > 0 ? [...new Set(values)] : undefined;
+}

package/src/utils/ids.ts

@@ -0,0 +1,12 @@
+import { randomBytes } from "node:crypto";
+
+export function createRunId(prefix = "team"): string {
+	const stamp = new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+	const suffix = randomBytes(4).toString("hex");
+	return `${prefix}_${stamp}_${suffix}`;
+}
+
+export function createTaskId(stepId: string, index: number): string {
+	const normalized = stepId.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "task";
+	return `${String(index + 1).padStart(2, "0")}_${normalized}`;
+}

package/src/utils/names.ts

@@ -0,0 +1,26 @@
+export function sanitizeName(name: string): string {
+	return name.toLowerCase().trim().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+export function requireString(value: unknown, label: string): { value?: string; error?: string } {
+	if (typeof value !== "string" || !value.trim()) return { error: `${label} must be a non-empty string.` };
+	return { value: value.trim() };
+}
+
+export function parseConfigObject(config: unknown): { value?: Record<string, unknown>; error?: string } {
+	let parsed = config;
+	if (typeof parsed === "string") {
+		try {
+			parsed = JSON.parse(parsed) as unknown;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return { error: `config must be valid JSON: ${message}` };
+		}
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { error: "config must be an object." };
+	return { value: parsed as Record<string, unknown> };
+}
+
+export function hasOwn(obj: Record<string, unknown>, key: string): boolean {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}

package/src/utils/paths.ts

@@ -0,0 +1,15 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function packageRoot(): string {
+	return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+}
+
+export function userPiRoot(): string {
+	return path.join(os.homedir(), ".pi", "agent");
+}
+
+export function projectPiRoot(cwd: string): string {
+	return path.join(cwd, ".pi");
+}

package/src/workflows/discover-workflows.ts

@@ -0,0 +1,101 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ResourceSource } from "../agents/agent-config.ts";
+import { parseCsv, parseFrontmatter } from "../utils/frontmatter.ts";
+import { packageRoot, projectPiRoot, userPiRoot } from "../utils/paths.ts";
+import type { WorkflowConfig, WorkflowStep } from "./workflow-config.ts";
+
+export interface WorkflowDiscoveryResult {
+	builtin: WorkflowConfig[];
+	user: WorkflowConfig[];
+	project: WorkflowConfig[];
+}
+
+function parseStepSection(id: string, body: string): WorkflowStep | undefined {
+	const lines = body.trim().split("\n");
+	const config: Record<string, string> = {};
+	const taskLines: string[] = [];
+	let inTask = false;
+	for (const line of lines) {
+		if (!inTask) {
+			if (line.trim() === "") {
+				inTask = true;
+				continue;
+			}
+			const match = line.match(/^([\w-]+):\s*(.*)$/);
+			if (match) {
+				config[match[1]!.trim()] = match[2]!.trim();
+				continue;
+			}
+			inTask = true;
+		}
+		taskLines.push(line);
+	}
+	const role = config.role || id;
+	return {
+		id,
+		role,
+		task: taskLines.join("\n").trim() || config.task || "{goal}",
+		dependsOn: parseCsv(config.dependsOn),
+		parallelGroup: config.parallelGroup || undefined,
+		output: config.output === "false" ? false : config.output || undefined,
+		reads: config.reads === "false" ? false : parseCsv(config.reads),
+		model: config.model || undefined,
+		skills: config.skills === "false" ? false : parseCsv(config.skills),
+		progress: config.progress === "true" ? true : config.progress === "false" ? false : undefined,
+		worktree: config.worktree === "true" ? true : config.worktree === "false" ? false : undefined,
+		verify: config.verify === "true" ? true : config.verify === "false" ? false : undefined,
+	};
+}
+
+function parseWorkflowFile(filePath: string, source: ResourceSource): WorkflowConfig | undefined {
+	try {
+		const content = fs.readFileSync(filePath, "utf-8");
+		const { frontmatter, body } = parseFrontmatter(content);
+		const name = frontmatter.name?.trim() || path.basename(filePath, ".workflow.md");
+		const matches = [...body.matchAll(/^##\s+(.+)[^\S\n]*$/gm)];
+		const steps: WorkflowStep[] = [];
+		for (let i = 0; i < matches.length; i++) {
+			const match = matches[i]!;
+			const id = match[1]!.trim();
+			const sectionStart = match.index! + match[0].length + (body[match.index! + match[0].length] === "\n" ? 1 : 0);
+			const sectionEnd = i + 1 < matches.length ? matches[i + 1]!.index! : body.length;
+			const step = parseStepSection(id, body.slice(sectionStart, sectionEnd));
+			if (step) steps.push(step);
+		}
+		return {
+			name,
+			description: frontmatter.description?.trim() || "No description provided.",
+			source,
+			filePath,
+			steps,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+function readWorkflowDir(dir: string, source: ResourceSource): WorkflowConfig[] {
+	if (!fs.existsSync(dir)) return [];
+	return fs.readdirSync(dir)
+		.filter((entry) => entry.endsWith(".workflow.md"))
+		.map((entry) => parseWorkflowFile(path.join(dir, entry), source))
+		.filter((workflow): workflow is WorkflowConfig => workflow !== undefined)
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function discoverWorkflows(cwd: string): WorkflowDiscoveryResult {
+	return {
+		builtin: readWorkflowDir(path.join(packageRoot(), "workflows"), "builtin"),
+		user: readWorkflowDir(path.join(userPiRoot(), "workflows"), "user"),
+		project: readWorkflowDir(path.join(projectPiRoot(cwd), "workflows"), "project"),
+	};
+}
+
+export function allWorkflows(discovery: WorkflowDiscoveryResult): WorkflowConfig[] {
+	const byName = new Map<string, WorkflowConfig>();
+	for (const workflow of [...discovery.builtin, ...discovery.user, ...discovery.project]) {
+		byName.set(workflow.name, workflow);
+	}
+	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}

package/src/workflows/validate-workflow.ts

@@ -0,0 +1,40 @@
+import type { TeamConfig } from "../teams/team-config.ts";
+import type { WorkflowConfig } from "./workflow-config.ts";
+
+export function validateWorkflowForTeam(workflow: WorkflowConfig, team: TeamConfig): string[] {
+	const errors: string[] = [];
+	const roles = new Set(team.roles.map((role) => role.name));
+	const stepIds = new Set<string>();
+
+	for (const step of workflow.steps) {
+		if (stepIds.has(step.id)) errors.push(`Duplicate workflow step id '${step.id}'.`);
+		stepIds.add(step.id);
+		if (!roles.has(step.role)) errors.push(`Step '${step.id}' references unknown team role '${step.role}'.`);
+	}
+
+	for (const step of workflow.steps) {
+		for (const dep of step.dependsOn ?? []) {
+			if (!stepIds.has(dep)) errors.push(`Step '${step.id}' depends on unknown step '${dep}'.`);
+		}
+	}
+
+	const visiting = new Set<string>();
+	const visited = new Set<string>();
+	const byId = new Map(workflow.steps.map((step) => [step.id, step]));
+
+	function visit(id: string, trail: string[]): void {
+		if (visited.has(id)) return;
+		if (visiting.has(id)) {
+			errors.push(`Workflow dependency cycle detected: ${[...trail, id].join(" -> ")}.`);
+			return;
+		}
+		visiting.add(id);
+		const step = byId.get(id);
+		for (const dep of step?.dependsOn ?? []) visit(dep, [...trail, id]);
+		visiting.delete(id);
+		visited.add(id);
+	}
+
+	for (const step of workflow.steps) visit(step.id, []);
+	return [...new Set(errors)];
+}

package/src/workflows/workflow-config.ts

@@ -0,0 +1,24 @@
+import type { ResourceSource } from "../agents/agent-config.ts";
+
+export interface WorkflowStep {
+	id: string;
+	role: string;
+	task: string;
+	dependsOn?: string[];
+	parallelGroup?: string;
+	output?: string | false;
+	reads?: string[] | false;
+	model?: string;
+	skills?: string[] | false;
+	progress?: boolean;
+	worktree?: boolean;
+	verify?: boolean;
+}
+
+export interface WorkflowConfig {
+	name: string;
+	description: string;
+	source: ResourceSource;
+	filePath: string;
+	steps: WorkflowStep[];
+}

package/src/workflows/workflow-serializer.ts

@@ -0,0 +1,31 @@
+import type { WorkflowConfig, WorkflowStep } from "./workflow-config.ts";
+
+function serializeStep(step: WorkflowStep): string[] {
+	const lines = [`## ${step.id}`, `role: ${step.role}`];
+	if (step.dependsOn?.length) lines.push(`dependsOn: ${step.dependsOn.join(", ")}`);
+	if (step.parallelGroup) lines.push(`parallelGroup: ${step.parallelGroup}`);
+	if (step.output === false) lines.push("output: false");
+	else if (step.output) lines.push(`output: ${step.output}`);
+	if (step.reads === false) lines.push("reads: false");
+	else if (Array.isArray(step.reads) && step.reads.length > 0) lines.push(`reads: ${step.reads.join(", ")}`);
+	if (step.model) lines.push(`model: ${step.model}`);
+	if (step.skills === false) lines.push("skills: false");
+	else if (Array.isArray(step.skills) && step.skills.length > 0) lines.push(`skills: ${step.skills.join(", ")}`);
+	if (step.progress !== undefined) lines.push(`progress: ${step.progress ? "true" : "false"}`);
+	if (step.worktree !== undefined) lines.push(`worktree: ${step.worktree ? "true" : "false"}`);
+	if (step.verify !== undefined) lines.push(`verify: ${step.verify ? "true" : "false"}`);
+	lines.push("", step.task.trim(), "");
+	return lines;
+}
+
+export function serializeWorkflow(workflow: WorkflowConfig): string {
+	const lines = [
+		"---",
+		`name: ${workflow.name}`,
+		`description: ${workflow.description}`,
+		"---",
+		"",
+		...workflow.steps.flatMap(serializeStep),
+	];
+	return lines.join("\n");
+}

package/src/worktree/cleanup.ts

@@ -0,0 +1,69 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { TeamRunManifest } from "../state/types.ts";
+import { writeArtifact } from "../state/artifact-store.ts";
+
+export interface WorktreeCleanupResult {
+	removed: string[];
+	preserved: Array<{ path: string; reason: string }>;
+	artifactPaths: string[];
+}
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+
+function isDirty(worktreePath: string): boolean {
+	try {
+		return git(worktreePath, ["status", "--porcelain"]).trim().length > 0;
+	} catch {
+		return true;
+	}
+}
+
+function captureDiff(worktreePath: string): string {
+	try {
+		return [git(worktreePath, ["status", "--porcelain"]), "", git(worktreePath, ["diff", "--stat"]), "", git(worktreePath, ["diff"])].join("\n");
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return `Failed to capture cleanup diff for ${worktreePath}: ${message}`;
+	}
+}
+
+export function cleanupRunWorktrees(manifest: TeamRunManifest, options: { force?: boolean } = {}): WorktreeCleanupResult {
+	const worktreeRoot = path.join(manifest.cwd, ".pi", "teams", "worktrees", manifest.runId);
+	const result: WorktreeCleanupResult = { removed: [], preserved: [], artifactPaths: [] };
+	if (!fs.existsSync(worktreeRoot)) return result;
+
+	for (const entry of fs.readdirSync(worktreeRoot)) {
+		const worktreePath = path.join(worktreeRoot, entry);
+		if (!fs.statSync(worktreePath).isDirectory()) continue;
+		const dirty = isDirty(worktreePath);
+		if (dirty && !options.force) {
+			const artifact = writeArtifact(manifest.artifactsRoot, {
+				kind: "diff",
+				relativePath: `cleanup/${entry}.diff`,
+				content: captureDiff(worktreePath),
+				producer: "worktree-cleanup",
+			});
+			result.artifactPaths.push(artifact.path);
+			result.preserved.push({ path: worktreePath, reason: "dirty worktree preserved" });
+			continue;
+		}
+		try {
+			git(manifest.cwd, ["worktree", "remove", options.force ? "--force" : "", worktreePath].filter(Boolean));
+			result.removed.push(worktreePath);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			result.preserved.push({ path: worktreePath, reason: message });
+		}
+	}
+
+	try {
+		if (fs.existsSync(worktreeRoot) && fs.readdirSync(worktreeRoot).length === 0) fs.rmSync(worktreeRoot, { recursive: true, force: true });
+	} catch {
+		// Non-critical cleanup.
+	}
+	return result;
+}

package/src/worktree/worktree-manager.ts

@@ -0,0 +1,60 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig } from "../config/config.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+
+export interface PreparedTaskWorkspace {
+	cwd: string;
+	worktreePath?: string;
+	branch?: string;
+	reused?: boolean;
+}
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+
+function sanitizeBranchPart(value: string): string {
+	return value.toLowerCase().replace(/[^a-z0-9._/-]+/g, "-").replace(/^-+|-+$/g, "") || "task";
+}
+
+export function findGitRoot(cwd: string): string {
+	return git(cwd, ["rev-parse", "--show-toplevel"]);
+}
+
+export function assertCleanLeader(repoRoot: string): void {
+	const status = git(repoRoot, ["status", "--porcelain"]);
+	if (status.trim()) {
+		throw new Error("Worktree mode requires a clean leader repository. Commit/stash changes or use workspaceMode: 'single'.");
+	}
+}
+
+export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskState): PreparedTaskWorkspace {
+	if (manifest.workspaceMode !== "worktree") return { cwd: task.cwd };
+	const repoRoot = findGitRoot(manifest.cwd);
+	const loadedConfig = loadConfig(manifest.cwd);
+	if (loadedConfig.config.requireCleanWorktreeLeader !== false) assertCleanLeader(repoRoot);
+	const worktreeRoot = path.join(repoRoot, ".pi", "teams", "worktrees", manifest.runId);
+	fs.mkdirSync(worktreeRoot, { recursive: true });
+	const worktreePath = path.join(worktreeRoot, task.id);
+	const branch = `pi-crew/${sanitizeBranchPart(manifest.runId)}/${sanitizeBranchPart(task.id)}`;
+	if (fs.existsSync(worktreePath)) {
+		const currentBranch = git(worktreePath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+		if (currentBranch !== branch) {
+			throw new Error(`Existing worktree branch mismatch at ${worktreePath}: expected '${branch}', got '${currentBranch}'.`);
+		}
+		return { cwd: worktreePath, worktreePath, branch, reused: true };
+	}
+	git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+	return { cwd: worktreePath, worktreePath, branch, reused: false };
+}
+
+export function captureWorktreeDiff(worktreePath: string): string {
+	try {
+		return git(worktreePath, ["diff", "--stat"]) + "\n\n" + git(worktreePath, ["diff"]);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return `Failed to capture worktree diff: ${message}`;
+	}
+}

package/teams/default.team.md

@@ -0,0 +1,12 @@
+---
+name: default
+description: Balanced team for ordinary implementation tasks
+defaultWorkflow: default
+workspaceMode: single
+maxConcurrency: 2
+---
+
+- explorer: agent=explorer fast discovery
+- planner: agent=planner plan the work
+- executor: agent=executor implement changes
+- verifier: agent=verifier verify completion

package/teams/fast-fix.team.md

@@ -0,0 +1,11 @@
+---
+name: fast-fix
+description: Small team for quick bug fixes
+defaultWorkflow: fast-fix
+workspaceMode: single
+maxConcurrency: 1
+---
+
+- explorer: agent=explorer find the relevant files
+- executor: agent=executor make the fix
+- verifier: agent=verifier verify the fix

package/teams/implementation.team.md

@@ -0,0 +1,15 @@
+---
+name: implementation
+description: Full implementation team with analysis, critique, execution, review, and verification
+defaultWorkflow: implementation
+workspaceMode: single
+maxConcurrency: 3
+---
+
+- explorer: agent=explorer map the codebase
+- analyst: agent=analyst clarify requirements and constraints
+- planner: agent=planner create execution plan
+- critic: agent=critic challenge the plan
+- executor: agent=executor implement the plan
+- reviewer: agent=reviewer review the implementation
+- verifier: agent=verifier verify done

package/teams/research.team.md

@@ -0,0 +1,11 @@
+---
+name: research
+description: Team for investigation and documentation
+defaultWorkflow: research
+workspaceMode: single
+maxConcurrency: 2
+---
+
+- explorer: agent=explorer gather codebase facts
+- analyst: agent=analyst analyze findings
+- writer: agent=writer produce final notes

package/teams/review.team.md

@@ -0,0 +1,12 @@
+---
+name: review
+description: Team for code review and security review
+defaultWorkflow: review
+workspaceMode: single
+maxConcurrency: 2
+---
+
+- explorer: agent=explorer understand changed areas
+- reviewer: agent=reviewer review correctness and maintainability
+- security-reviewer: agent=security-reviewer review security risks
+- verifier: agent=verifier summarize pass/fail

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noImplicitAny": true,
+    "exactOptionalPropertyTypes": false,
+    "skipLibCheck": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": [
+    "*.ts",
+    "src/**/*.ts",
+    "src/**/*.ts"
+  ]
+}