pi-crew 0.2.2 → 0.2.4

package/src/worktree/cleanup.ts

@@ -1,72 +1,75 @@
-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";
-import { projectCrewRoot } from "../utils/paths.ts";
-import { DEFAULT_PATHS } from "../config/defaults.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; signal?: AbortSignal } = {}): WorktreeCleanupResult {
-	const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, manifest.runId);
-	const result: WorktreeCleanupResult = { removed: [], preserved: [], artifactPaths: [] };
-	if (!fs.existsSync(worktreeRoot)) return result;
-
-	for (const entry of fs.readdirSync(worktreeRoot)) {
-		if (options.signal?.aborted) break;
-		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;
-}
+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";
+import { projectCrewRoot } from "../utils/paths.ts";
+import { DEFAULT_PATHS } from "../config/defaults.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"], env: { ...process.env, LANG: "C", LC_ALL: "C" } }).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; signal?: AbortSignal } = {}): WorktreeCleanupResult {
+	const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, manifest.runId);
+	const result: WorktreeCleanupResult = { removed: [], preserved: [], artifactPaths: [] };
+	if (!fs.existsSync(worktreeRoot)) return result;
+
+	for (const entry of fs.readdirSync(worktreeRoot)) {
+		if (options.signal?.aborted) break;
+		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;
+		}
+		const args = ["worktree", "remove"];
+		if (options.force) args.push("--force");
+		args.push(worktreePath);
+		try {
+			git(manifest.cwd, args);
+			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

@@ -1,146 +1,188 @@
-import { execFileSync, spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { loadConfig } from "../config/config.ts";
-import { projectCrewRoot } from "../utils/paths.ts";
-import { DEFAULT_PATHS } from "../config/defaults.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-
-export interface PreparedTaskWorkspace {
-	cwd: string;
-	worktreePath?: string;
-	branch?: string;
-	reused?: boolean;
-	nodeModulesLinked?: boolean;
-	syntheticPaths?: string[];
-}
-
-export interface WorktreeDiffStat {
-	filesChanged: number;
-	insertions: number;
-	deletions: number;
-	diffStat: string;
-}
-
-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'.");
-	}
-}
-
-function linkNodeModulesIfPresent(repoRoot: string, worktreePath: string): boolean {
-	const source = path.join(repoRoot, "node_modules");
-	const target = path.join(worktreePath, "node_modules");
-	if (!fs.existsSync(source) || fs.existsSync(target)) return false;
-	try {
-		fs.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-function normalizeSyntheticPath(worktreePath: string, rawPath: string): string {
-	const resolved = path.resolve(worktreePath, rawPath);
-	const relative = path.relative(worktreePath, resolved);
-	if (!relative || relative === "." || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`synthetic path escapes worktree: ${rawPath}`);
-	return path.normalize(relative);
-}
-
-function runSetupHook(manifest: TeamRunManifest, task: TeamTaskState, repoRoot: string, worktreePath: string, branch: string): string[] {
-	const cfg = loadConfig(manifest.cwd).config.worktree;
-	if (!cfg?.setupHook) return [];
-	const hookPath = path.isAbsolute(cfg.setupHook) ? cfg.setupHook : path.resolve(repoRoot, cfg.setupHook);
-	if (!fs.existsSync(hookPath) || fs.statSync(hookPath).isDirectory()) throw new Error(`worktree setup hook not found or not a file: ${hookPath}`);
-	const nodeHook = hookPath.endsWith(".js") || hookPath.endsWith(".cjs") || hookPath.endsWith(".mjs");
-	const result = spawnSync(nodeHook ? process.execPath : hookPath, nodeHook ? [hookPath] : [], {
-		cwd: worktreePath,
-		encoding: "utf-8",
-		input: JSON.stringify({ version: 1, repoRoot, worktreePath, agentCwd: worktreePath, branch, runId: manifest.runId, taskId: task.id, agent: task.agent }),
-		timeout: cfg.setupHookTimeoutMs ?? 30_000,
-		shell: false,
-	});
-	if (result.error) throw new Error(`worktree setup hook failed: ${result.error.message}`);
-	if (result.status !== 0) throw new Error(`worktree setup hook failed with exit code ${result.status}: ${result.stderr || result.stdout || "no output"}`);
-	const trimmed = result.stdout.trim();
-	if (!trimmed) return [];
-	try {
-		// Extract JSON from last line — hooks may output debug logging before JSON
-		const lines = trimmed.split(/\r?\n/);
-		const lastLine = lines[lines.length - 1] ?? trimmed;
-		const parsed = JSON.parse(lastLine) as { syntheticPaths?: unknown };
-		if (!Array.isArray(parsed.syntheticPaths)) return [];
-		return [...new Set(parsed.syntheticPaths.filter((entry): entry is string => typeof entry === "string").map((entry) => normalizeSyntheticPath(worktreePath, entry)))];
-	} catch {
-		// Hook output was not valid JSON — treat as no synthetic paths
-		return [];
-	}
-}
-
-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(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, 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)) {
-		let currentBranch: string;
-		try {
-			currentBranch = git(worktreePath, ["rev-parse", "--abbrev-ref", "HEAD"]);
-		} catch (gitError) {
-			throw new Error(`Existing worktree at ${worktreePath} is not a valid git repository; cannot verify branch: ${gitError instanceof Error ? gitError.message : String(gitError)}`);
-		}
-		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"]);
-	const syntheticPaths = runSetupHook(manifest, task, repoRoot, worktreePath, branch);
-	const nodeModulesLinked = loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
-	return { cwd: worktreePath, worktreePath, branch, reused: false, nodeModulesLinked, syntheticPaths };
-}
-
-export function captureWorktreeDiffStat(worktreePath: string): WorktreeDiffStat {
-	try {
-		const diffStat = git(worktreePath, ["diff", "--stat"]);
-		const numstat = git(worktreePath, ["diff", "--numstat"]);
-		let filesChanged = 0;
-		let insertions = 0;
-		let deletions = 0;
-		for (const line of numstat.split(/\r?\n/).filter(Boolean)) {
-			const [add, del] = line.split(/\s+/);
-			filesChanged += 1;
-			insertions += Number(add) || 0;
-			deletions += Number(del) || 0;
-		}
-		return { filesChanged, insertions, deletions, diffStat };
-	} catch {
-		return { filesChanged: 0, insertions: 0, deletions: 0, diffStat: "" };
-	}
-}
-
-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}`;
-	}
-}
+import { execFileSync, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig } from "../config/config.ts";
+import { projectCrewRoot } from "../utils/paths.ts";
+import { DEFAULT_PATHS } from "../config/defaults.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+
+export interface PreparedTaskWorkspace {
+	cwd: string;
+	worktreePath?: string;
+	branch?: string;
+	reused?: boolean;
+	nodeModulesLinked?: boolean;
+	syntheticPaths?: string[];
+}
+
+export interface WorktreeDiffStat {
+	filesChanged: number;
+	insertions: number;
+	deletions: number;
+	diffStat: string;
+}
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" } }).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'.");
+	}
+}
+
+function linkNodeModulesIfPresent(repoRoot: string, worktreePath: string): boolean {
+	const source = path.join(repoRoot, "node_modules");
+	const target = path.join(worktreePath, "node_modules");
+	let sourceStat: fs.Stats;
+	try { sourceStat = fs.statSync(source); } catch { return false; }
+	if (!sourceStat.isDirectory()) return false;
+	if (fs.existsSync(target)) return false;
+	try {
+		fs.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function normalizeSyntheticPath(worktreePath: string, rawPath: string): string {
+	const resolved = path.resolve(worktreePath, rawPath);
+	const relative = path.relative(worktreePath, resolved);
+	if (!relative || relative === "." || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`synthetic path escapes worktree: ${rawPath}`);
+	return path.normalize(relative);
+}
+
+function runSetupHook(manifest: TeamRunManifest, task: TeamTaskState, repoRoot: string, worktreePath: string, branch: string): string[] {
+	const cfg = loadConfig(manifest.cwd).config.worktree;
+	if (!cfg?.setupHook) return [];
+	const hookPath = path.isAbsolute(cfg.setupHook) ? cfg.setupHook : path.resolve(repoRoot, cfg.setupHook);
+	if (!fs.existsSync(hookPath) || fs.statSync(hookPath).isDirectory()) throw new Error(`worktree setup hook not found or not a file: ${hookPath}`);
+	const nodeHook = hookPath.endsWith(".js") || hookPath.endsWith(".cjs") || hookPath.endsWith(".mjs");
+	const result = spawnSync(nodeHook ? process.execPath : hookPath, nodeHook ? [hookPath] : [], {
+		cwd: worktreePath,
+		encoding: "utf-8",
+		input: JSON.stringify({ version: 1, repoRoot, worktreePath, agentCwd: worktreePath, branch, runId: manifest.runId, taskId: task.id, agent: task.agent }),
+		timeout: cfg.setupHookTimeoutMs ?? 30_000,
+		shell: false,
+		env: sanitizeEnvSecrets(process.env, {
+			allowList: ["PATH", "HOME", "USERPROFILE", "TEMP", "TMP", "TMPDIR", "LANG", "LC_ALL", "PI_*"],
+		}),
+	});
+	if (result.error) throw new Error(`worktree setup hook failed: ${result.error.message}`);
+	if (result.status !== 0) throw new Error(`worktree setup hook failed with exit code ${result.status}: ${result.stderr || result.stdout || "no output"}`);
+	const trimmed = result.stdout.trim();
+	if (!trimmed) return [];
+	try {
+		// Extract JSON from last line — hooks may output debug logging before JSON
+		const lines = trimmed.split(/\r?\n/);
+		const lastLine = lines[lines.length - 1] ?? trimmed;
+		const parsed = JSON.parse(lastLine) as { syntheticPaths?: unknown };
+		if (!Array.isArray(parsed.syntheticPaths)) return [];
+		return [...new Set(parsed.syntheticPaths.filter((entry): entry is string => typeof entry === "string").map((entry) => normalizeSyntheticPath(worktreePath, entry)))];
+	} catch (error) {
+		logInternalError("worktree.setupHook.parse", error, `lastLine=${(trimmed.split(/\r?\n/).pop() ?? "").slice(0, 200)}`);
+		return [];
+	}
+}
+
+function branchExists(repoRoot: string, branch: string): { local: boolean; remoteOnly: boolean } {
+	let local = false;
+	try { git(repoRoot, ["rev-parse", "--verify", `refs/heads/${branch}`]); local = true; } catch {}
+	if (local) return { local: true, remoteOnly: false };
+	// Check remote-tracking branch
+	try {
+		const out = execFileSync("git", ["for-each-ref", "--format=%(refname)", `refs/remotes/*/${branch}`],
+			{ cwd: repoRoot, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+		return { local: false, remoteOnly: out.length > 0 };
+	} catch { return { local: false, remoteOnly: false }; }
+}
+
+function pruneStaleWorktrees(repoRoot: string): void {
+	try { execFileSync("git", ["worktree", "prune"], { cwd: repoRoot, stdio: "ignore" }); }
+	catch { /* best-effort */ }
+}
+
+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(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, 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)) {
+		let currentBranch: string;
+		try {
+			currentBranch = git(worktreePath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+		} catch (gitError) {
+			throw new Error(`Existing worktree at ${worktreePath} is not a valid git repository; cannot verify branch: ${gitError instanceof Error ? gitError.message : String(gitError)}`);
+		}
+		if (currentBranch !== branch) {
+			throw new Error(`Existing worktree branch mismatch at ${worktreePath}: expected '${branch}', got '${currentBranch}'.`);
+		}
+		return { cwd: worktreePath, worktreePath, branch, reused: true };
+	}
+	pruneStaleWorktrees(repoRoot);
+	const exists = branchExists(repoRoot, branch);
+	try {
+		if (exists.local) {
+			git(repoRoot, ["worktree", "add", worktreePath, branch]);
+		} else {
+			if (exists.remoteOnly) {
+				logInternalError("worktree.branchRemoteOnly", new Error(`Branch '${branch}' exists only on remote; creating local from HEAD instead of tracking remote.`), `branch=${branch}`);
+			}
+			git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+		}
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		if (/already checked out|is already used by worktree/i.test(msg)) {
+			throw new Error(`Branch '${branch}' is checked out at another worktree. Run \`team cleanup runId=${manifest.runId} force=true\` or manually remove the conflicting worktree.`);
+		}
+		throw error;
+	}
+	const syntheticPaths = runSetupHook(manifest, task, repoRoot, worktreePath, branch);
+	const nodeModulesLinked = loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
+	return { cwd: worktreePath, worktreePath, branch, reused: false, nodeModulesLinked, syntheticPaths };
+}
+
+export function captureWorktreeDiffStat(worktreePath: string): WorktreeDiffStat {
+	try {
+		const diffStat = git(worktreePath, ["diff", "--stat"]);
+		const numstat = git(worktreePath, ["diff", "--numstat"]);
+		let filesChanged = 0;
+		let insertions = 0;
+		let deletions = 0;
+		for (const line of numstat.split(/\r?\n/).filter(Boolean)) {
+			const [add, del] = line.split(/\s+/);
+			filesChanged += 1;
+			insertions += Number(add) || 0;
+			deletions += Number(del) || 0;
+		}
+		return { filesChanged, insertions, deletions, diffStat };
+	} catch {
+		return { filesChanged: 0, insertions: 0, deletions: 0, diffStat: "" };
+	}
+}
+
+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

@@ -1,12 +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
+---
+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

@@ -1,11 +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
+---
+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

@@ -1,18 +1,18 @@
----
-name: implementation
-description: Full implementation team with parallel specialists, 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 and synthesize specialist findings
-- executor: agent=executor implement the plan
-- reviewer: agent=reviewer review the implementation
-- security-reviewer: agent=security-reviewer review security and trust boundaries
-- test-engineer: agent=test-engineer design and run verification
-- verifier: agent=verifier verify done
-- writer: agent=writer summarize documentation or release notes when needed
+---
+name: implementation
+description: Full implementation team with parallel specialists, 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 and synthesize specialist findings
+- executor: agent=executor implement the plan
+- reviewer: agent=reviewer review the implementation
+- security-reviewer: agent=security-reviewer review security and trust boundaries
+- test-engineer: agent=test-engineer design and run verification
+- verifier: agent=verifier verify done
+- writer: agent=writer summarize documentation or release notes when needed

package/teams/parallel-research.team.md

@@ -1,14 +1,14 @@
----
-name: parallel-research
-description: Parallel research team for multi-project/source audits
-workspaceMode: single
-defaultWorkflow: parallel-research
-maxConcurrency: 4
-triggers: đọc sâu, deep read, deep research, source audit, multiple projects, parallel research, pi-*
-category: research
-cost: cheap
----
-
-- explorer: agent=explorer gather source facts in parallel shards
-- analyst: agent=analyst synthesize shard findings
-- writer: agent=writer produce final notes
+---
+name: parallel-research
+description: Parallel research team for multi-project/source audits
+workspaceMode: single
+defaultWorkflow: parallel-research
+maxConcurrency: 4
+triggers: đọc sâu, deep read, deep research, source audit, multiple projects, parallel research, pi-*
+category: research
+cost: cheap
+---
+
+- explorer: agent=explorer gather source facts in parallel shards
+- analyst: agent=analyst synthesize shard findings
+- writer: agent=writer produce final notes

package/teams/research.team.md

@@ -1,11 +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
+---
+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