pi-mono-all 1.0.0

package/node_modules/pi-mono-team-mode/managers/delegation-manager.ts

@@ -0,0 +1,211 @@
+import { randomUUID } from "node:crypto";
+
+import {
+	applyTemplate,
+	createChainDir,
+	expandCountedTasks,
+	isParallelChainStep,
+	readStepInputs,
+	type DelegateChainStep,
+	type DelegateTask,
+	writeStepOutput,
+} from "../core/chain-utils.js";
+import { aggregateParallelOutputs, DEFAULT_PARALLEL_CONCURRENCY, mapConcurrent } from "../core/parallel-utils.js";
+import type { ExecutionRuntime, IsolationMode, TeammateRunResult } from "../core/types.js";
+import type { AgentManager } from "./agent-manager.js";
+
+const DEFAULT_MAX_PARALLEL = 8;
+
+export type DelegationResult = {
+	mode: "parallel" | "chain";
+	output: string;
+	steps: number;
+	chainDir?: string;
+};
+
+export type RunParallelInput = {
+	tasks: DelegateTask[];
+	concurrency?: number;
+	isolation?: IsolationMode;
+	runtime?: ExecutionRuntime;
+};
+
+export type RunChainInput = {
+	task: string;
+	chain: DelegateChainStep[];
+	concurrency?: number;
+	isolation?: IsolationMode;
+	runtime?: ExecutionRuntime;
+};
+
+export class DelegationManager {
+	constructor(private readonly agents: AgentManager) {}
+
+	async runParallel(input: RunParallelInput): Promise<DelegationResult> {
+		const expanded = expandCountedTasks(input.tasks);
+		const maxParallel = readMaxParallel();
+		if (expanded.length === 0) throw new Error("delegate.tasks must include at least one task");
+		if (expanded.length > maxParallel) {
+			throw new Error(`delegate.tasks exceeds max tasks (${maxParallel})`);
+		}
+
+		const concurrency = boundedConcurrency(input.concurrency);
+		let launched = 0;
+		this.agents.setQueuedCount(Math.max(0, expanded.length - Math.min(expanded.length, concurrency)));
+		try {
+			const results = await mapConcurrent(expanded, concurrency, async (task, index) => {
+				launched += 1;
+				this.agents.setQueuedCount(Math.max(0, expanded.length - launched));
+				return this.runTask(task, index, input.isolation, input.runtime);
+			});
+			return {
+				mode: "parallel",
+				steps: expanded.length,
+				output: aggregateParallelOutputs(results.map(toParallelResult)),
+			};
+		} finally {
+			this.agents.setQueuedCount(0);
+		}
+	}
+
+	async runChain(input: RunChainInput): Promise<DelegationResult> {
+		if (input.chain.length === 0) throw new Error("delegate.chain must include at least one step");
+		const runId = `chain-${randomUUID().slice(0, 8)}`;
+		const chainDir = await createChainDir(runId);
+		let previous = "";
+		const topConcurrency = boundedConcurrency(input.concurrency);
+
+		for (let i = 0; i < input.chain.length; i += 1) {
+			const step = input.chain[i];
+			if (isParallelChainStep(step)) {
+				const expanded = expandCountedTasks(step.parallel);
+				const maxParallel = readMaxParallel();
+				if (expanded.length > maxParallel) {
+					throw new Error(`delegate.chain parallel step ${i + 1} exceeds max tasks (${maxParallel})`);
+				}
+				const concurrency = boundedConcurrency(step.concurrency ?? topConcurrency);
+				let launched = 0;
+				let failFastTriggered = false;
+				this.agents.setQueuedCount(Math.max(0, expanded.length - Math.min(expanded.length, concurrency)));
+				try {
+					const runs = await mapConcurrent(expanded, concurrency, async (task, index) => {
+						if (step.failFast && failFastTriggered) {
+							return skippedResult(task, index);
+						}
+						launched += 1;
+						this.agents.setQueuedCount(Math.max(0, expanded.length - launched));
+						const renderedTask = await withTemplatedTask(task, input.task, previous, chainDir);
+						const run = await this.runTask(
+							renderedTask,
+							index,
+							step.isolation ?? input.isolation,
+							step.runtime ?? input.runtime,
+						);
+						await writeStepOutput(chainDir, renderedTask.output, run.result);
+						if (step.failFast && run.status !== "completed") failFastTriggered = true;
+						return run;
+					});
+					previous = aggregateParallelOutputs(runs.map(toParallelResult));
+					if (step.failFast && runs.some((r) => r.status !== "completed")) {
+						break;
+					}
+				} finally {
+					this.agents.setQueuedCount(0);
+				}
+				continue;
+			}
+
+			const stepTask = await withTemplatedTask(step, input.task, previous, chainDir);
+			const result = await this.runTask(stepTask, i, input.isolation, input.runtime);
+			await writeStepOutput(chainDir, stepTask.output, result.result);
+			previous = result.result;
+		}
+
+		return {
+			mode: "chain",
+			steps: input.chain.length,
+			chainDir,
+			output: previous,
+		};
+	}
+
+	private async runTask(
+		task: DelegateTask,
+		index: number,
+		defaultIsolation?: IsolationMode,
+		defaultRuntime?: ExecutionRuntime,
+	): Promise<TeammateRunResult> {
+		const name = task.name?.trim();
+		const result = await this.agents.spawn({
+			description: task.description,
+			prompt: task.prompt,
+			name,
+			teamId: task.teamId,
+			subagentType: task.subagentType,
+			model: task.model,
+			thinkingLevel: task.thinkingLevel,
+			isolation: task.isolation ?? defaultIsolation,
+			runtime: task.runtime ?? defaultRuntime,
+			background: false,
+			cwd: task.cwd,
+		});
+		return result;
+	}
+}
+
+type TemplatedTask = DelegateTask;
+
+async function withTemplatedTask(
+	task: DelegateTask,
+	rootTask: string,
+	previous: string,
+	chainDir: string,
+): Promise<TemplatedTask> {
+	const readPrefix = await readStepInputs(chainDir, task.reads);
+	const taskTemplate = `${readPrefix}${task.prompt}`;
+	return {
+		...task,
+		prompt: applyTemplate(taskTemplate, { task: rootTask, previous, chainDir }),
+	};
+}
+
+function toParallelResult(run: TeammateRunResult) {
+	return {
+		name: run.name,
+		output: run.result,
+		exitCode: run.exitCode,
+		error: run.status === "completed" ? undefined : run.result,
+	};
+}
+
+function skippedResult(task: DelegateTask, index: number): TeammateRunResult {
+	return {
+		teammateId: `skipped-${index + 1}`,
+		name: task.name ?? `task-${index + 1}`,
+		description: task.description,
+		status: "failed",
+		result: "[skipped due to failFast]",
+		exitCode: null,
+	};
+}
+
+function boundedConcurrency(input: number | undefined): number {
+	const parsed = Number.isFinite(input) ? Math.floor(input as number) : readDefaultConcurrency();
+	return Math.max(1, parsed);
+}
+
+function readDefaultConcurrency(): number {
+	const env = process.env.PI_TEAM_MATE_PARALLEL_CONCURRENCY;
+	if (!env) return DEFAULT_PARALLEL_CONCURRENCY;
+	const parsed = Number.parseInt(env, 10);
+	if (!Number.isFinite(parsed) || parsed < 1) return DEFAULT_PARALLEL_CONCURRENCY;
+	return parsed;
+}
+
+function readMaxParallel(): number {
+	const env = process.env.PI_TEAM_MATE_MAX_PARALLEL;
+	if (!env) return DEFAULT_MAX_PARALLEL;
+	const parsed = Number.parseInt(env, 10);
+	if (!Number.isFinite(parsed) || parsed < 1) return DEFAULT_MAX_PARALLEL;
+	return parsed;
+}

package/node_modules/pi-mono-team-mode/managers/task-manager.ts

@@ -0,0 +1,238 @@
+// Pi Team-Mode — Task Manager
+//
+// TODO-list CRUD matching Claude Code's TaskCreate/TaskUpdate/TaskList/TaskGet
+// semantics. Coordinator assigns via TaskUpdate({ owner }); there is no
+// auto-claim. update() takes a filesystem lock + CAS version counter so
+// concurrent edits from teammate subprocesses don't clobber each other.
+
+import { spawn } from "node:child_process";
+import { mkdir, open, unlink } from "node:fs/promises";
+import * as path from "node:path";
+
+import {
+	generateTaskId,
+	type TaskRecord,
+	type TaskStatus,
+	type TaskStore,
+} from "../core/tasks.js";
+
+const HOOK_TIMEOUT_MS = 120_000;
+const LOCK_RETRY_DELAY_MS = 20;
+const LOCK_MAX_ATTEMPTS = 100;
+const LOCK_STALE_MS = 10_000;
+
+export type TaskCreateOpts = {
+	subject: string;
+	description?: string;
+	activeForm?: string;
+	metadata?: Record<string, unknown>;
+	teamId?: string;
+};
+
+export type TaskUpdateOpts = {
+	expectedVersion?: number;
+	status?: TaskStatus;
+	owner?: string | null;
+	subject?: string;
+	description?: string;
+	activeForm?: string;
+	result?: string;
+	addBlocks?: string[];
+	addBlockedBy?: string[];
+	metadata?: Record<string, unknown>;
+};
+
+export type TaskManagerDeps = {
+	store: TaskStore;
+	getParentSessionId: () => string;
+	getTaskCompletedHook?: () => Promise<string | undefined> | string | undefined;
+	getCwd?: () => string;
+};
+
+export class TaskManager {
+	constructor(private readonly deps: TaskManagerDeps) {}
+
+	async create(opts: TaskCreateOpts): Promise<TaskRecord> {
+		const parentSessionId = this.deps.getParentSessionId();
+		const now = new Date().toISOString();
+		const record: TaskRecord = {
+			id: generateTaskId(opts.subject),
+			subject: opts.subject,
+			description: opts.description,
+			activeForm: opts.activeForm,
+			status: "pending",
+			owner: null,
+			blockedBy: [],
+			blocks: [],
+			metadata: opts.metadata,
+			parentSessionId,
+			teamId: opts.teamId,
+			createdAt: now,
+			updatedAt: now,
+			version: 1,
+		};
+		await this.deps.store.save(record);
+		return record;
+	}
+
+	async update(taskId: string, opts: TaskUpdateOpts): Promise<TaskRecord> {
+		const parentSessionId = this.deps.getParentSessionId();
+		return withTaskLock(this.deps.store.dir(parentSessionId), taskId, async () => {
+			const current = await this.deps.store.load(parentSessionId, taskId);
+			if (!current) throw new Error(`unknown task: ${taskId}`);
+			if (opts.expectedVersion !== undefined && current.version !== opts.expectedVersion) {
+				throw new VersionConflictError(current.version, opts.expectedVersion);
+			}
+
+			const nextStatus = opts.status ?? current.status;
+			const transitioningToCompleted =
+				current.status !== "completed" && nextStatus === "completed";
+
+			const updated: TaskRecord = {
+				...current,
+				subject: opts.subject ?? current.subject,
+				description: opts.description ?? current.description,
+				activeForm: opts.activeForm ?? current.activeForm,
+				owner: opts.owner === undefined ? current.owner : opts.owner,
+				status: nextStatus,
+				result: opts.result ?? current.result,
+				blockedBy: opts.addBlockedBy
+					? Array.from(new Set([...current.blockedBy, ...opts.addBlockedBy]))
+					: current.blockedBy,
+				blocks: opts.addBlocks
+					? Array.from(new Set([...current.blocks, ...opts.addBlocks]))
+					: current.blocks,
+				metadata: opts.metadata
+					? { ...(current.metadata ?? {}), ...opts.metadata }
+					: current.metadata,
+				updatedAt: new Date().toISOString(),
+				version: current.version + 1,
+			};
+
+			if (transitioningToCompleted) {
+				const hook = await this.deps.getTaskCompletedHook?.();
+				if (hook && hook.trim()) {
+					const hookResult = await this.runHook(hook, updated);
+					updated.hookOutput = hookResult.output;
+					if (hookResult.exitCode !== 0) {
+						updated.status = "failed";
+						updated.result = `${updated.result ? updated.result + "\n\n" : ""}[TaskCompleted hook failed, exit ${hookResult.exitCode}] ${hook}`;
+					}
+				}
+			}
+
+			await this.deps.store.save(updated);
+			return updated;
+		});
+	}
+
+	async get(taskId: string): Promise<TaskRecord | null> {
+		return this.deps.store.load(this.deps.getParentSessionId(), taskId);
+	}
+
+	async list(filter?: {
+		status?: TaskStatus;
+		owner?: string;
+		teamId?: string;
+	}): Promise<TaskRecord[]> {
+		const all = await this.deps.store.list(this.deps.getParentSessionId());
+		let result = all;
+		if (filter?.status) result = result.filter((t) => t.status === filter.status);
+		if (filter?.owner) result = result.filter((t) => t.owner === filter.owner);
+		if (filter?.teamId) result = result.filter((t) => t.teamId === filter.teamId);
+		return result;
+	}
+
+	async clear(): Promise<void> {
+		await this.deps.store.clear(this.deps.getParentSessionId());
+	}
+
+	private async runHook(
+		hook: string,
+		task: TaskRecord,
+	): Promise<{ exitCode: number; output: string }> {
+		const cwd = this.deps.getCwd?.() ?? process.cwd();
+		return new Promise((resolve) => {
+			const proc = spawn("sh", ["-c", hook], {
+				cwd,
+				env: {
+					...process.env,
+					PI_TEAM_MATE_TASK_ID: task.id,
+					PI_TEAM_MATE_TASK_SUBJECT: task.subject,
+					PI_TEAM_MATE_TASK_OWNER: task.owner ?? "",
+				},
+				stdio: ["ignore", "pipe", "pipe"],
+			});
+			let output = "";
+			const append = (chunk: Buffer) => {
+				if (output.length < 8192) output += chunk.toString("utf8");
+			};
+			proc.stdout.on("data", append);
+			proc.stderr.on("data", append);
+			const timer = setTimeout(() => {
+				proc.kill("SIGTERM");
+				output += `\n[hook timed out after ${HOOK_TIMEOUT_MS}ms]`;
+			}, HOOK_TIMEOUT_MS);
+			timer.unref();
+			proc.on("close", (code) => {
+				clearTimeout(timer);
+				resolve({ exitCode: code ?? 1, output: output.trim() });
+			});
+			proc.on("error", (err) => {
+				clearTimeout(timer);
+				resolve({ exitCode: 1, output: `[hook spawn error] ${err.message}` });
+			});
+		});
+	}
+}
+
+export class VersionConflictError extends Error {
+	constructor(public readonly actual: number, public readonly expected: number) {
+		super(`version conflict: expected ${expected}, got ${actual}`);
+		this.name = "VersionConflictError";
+	}
+}
+
+async function withTaskLock<T>(
+	taskDir: string,
+	taskId: string,
+	fn: () => Promise<T>,
+): Promise<T> {
+	await mkdir(taskDir, { recursive: true });
+	const lockPath = path.join(taskDir, `${taskId}.lock`);
+
+	for (let attempt = 0; attempt < LOCK_MAX_ATTEMPTS; attempt++) {
+		try {
+			const handle = await open(lockPath, "wx");
+			await handle.writeFile(String(process.pid));
+			await handle.close();
+			try {
+				return await fn();
+			} finally {
+				await unlink(lockPath).catch(() => {});
+			}
+		} catch (err) {
+			if ((err as NodeJS.ErrnoException).code !== "EEXIST") throw err;
+			if (await isStaleLock(lockPath)) {
+				await unlink(lockPath).catch(() => {});
+				continue;
+			}
+			await delay(LOCK_RETRY_DELAY_MS + Math.random() * LOCK_RETRY_DELAY_MS);
+		}
+	}
+	throw new Error(`could not acquire task lock after ${LOCK_MAX_ATTEMPTS} attempts: ${lockPath}`);
+}
+
+async function isStaleLock(lockPath: string): Promise<boolean> {
+	try {
+		const { stat } = await import("node:fs/promises");
+		const st = await stat(lockPath);
+		return Date.now() - st.mtimeMs > LOCK_STALE_MS;
+	} catch {
+		return false;
+	}
+}
+
+function delay(ms: number): Promise<void> {
+	return new Promise((r) => setTimeout(r, ms));
+}

package/node_modules/pi-mono-team-mode/managers/team-manager.ts

@@ -0,0 +1,59 @@
+/**
+ * Pi Team-Mode — Team Manager
+ *
+ * Teams are lightweight namespaces that group teammates. Creating one returns
+ * a stable id; deleting one stops all its teammates and removes their records.
+ */
+
+import type { TeamMateStore } from "../core/store.js";
+import { generateTeamId } from "../core/store.js";
+import type { IsolationMode, TeamRecord } from "../core/types.js";
+import type { AgentManager } from "./agent-manager.js";
+
+export type TeamCreateOpts = {
+	name: string;
+	defaultIsolation?: IsolationMode;
+	worktreeBase?: string;
+};
+
+export class TeamManager {
+	constructor(
+		private readonly store: TeamMateStore,
+		private readonly agents: AgentManager,
+		private readonly getParentSessionId: () => string,
+	) {}
+
+	async create(opts: TeamCreateOpts): Promise<TeamRecord> {
+		const record: TeamRecord = {
+			id: generateTeamId(opts.name),
+			name: opts.name,
+			createdAt: new Date().toISOString(),
+			defaultIsolation: opts.defaultIsolation ?? "none",
+			worktreeBase: opts.worktreeBase,
+			parentSessionId: this.getParentSessionId(),
+		};
+		await this.store.saveTeam(record);
+		return record;
+	}
+
+	async delete(teamId: string): Promise<void> {
+		const team = await this.store.loadTeam(teamId);
+		if (!team) throw new Error(`unknown team: ${teamId}`);
+		const teammates = (await this.agents.list()).filter((t) => t.teamId === teamId);
+		await Promise.all(
+			teammates.map(async (t) => {
+				await this.agents.stop(t.id).catch(() => {});
+				await this.store.deleteTeammate(t.id);
+			}),
+		);
+		await this.store.deleteTeam(teamId);
+	}
+
+	async list(): Promise<TeamRecord[]> {
+		return this.store.listTeams();
+	}
+
+	async get(teamId: string): Promise<TeamRecord | null> {
+		return this.store.loadTeam(teamId);
+	}
+}

package/node_modules/pi-mono-team-mode/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "pi-mono-team-mode",
+  "version": "2.3.1",
+  "description": "Pi extension for flat peer-agent orchestration — named, addressable teammates with resumable context (mirrors Claude Code's team-mate model)",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension"
+  ],
+  "scripts": {
+    "test": "npx tsx --test '__tests__/**/*.test.ts'"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emanuelcasco/pi-mono-extensions.git",
+    "directory": "extensions/team-mode"
+  },
+  "bugs": {
+    "url": "https://github.com/emanuelcasco/pi-mono-extensions/issues"
+  },
+  "homepage": "https://github.com/emanuelcasco/pi-mono-extensions#readme"
+}