@tmustier/pi-agent-teams 0.4.0 → 0.5.1

package/extensions/teams/teams-widget.ts

@@ -1,21 +1,28 @@
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import type { Component, TUI } from "@mariozechner/pi-tui";
 import type { Theme, ThemeColor } from "@mariozechner/pi-coding-agent";
-import type { TeammateRpc, TeammateStatus } from "./teammate-rpc.js";
+import type { TeammateRpc } from "./teammate-rpc.js";
 import type { ActivityTracker } from "./activity-tracker.js";
 import type { TeamTask } from "./task-store.js";
 import type { TeamConfig, TeamMember } from "./team-config.js";
 import type { TeamsStyle } from "./teams-style.js";
 import { formatMemberDisplayName, getTeamsStrings } from "./teams-style.js";
 import {
-	STATUS_COLOR,
-	STATUS_ICON,
+	DISPLAY_STATUS_COLOR,
+	DISPLAY_STATUS_ICON,
+	formatElapsed,
 	formatTokens,
+	getMemberModel,
+	getMemberThinking,
 	getVisibleWorkerNames,
+	isTeamDone,
 	padRight,
-	resolveStatus,
+	renderPolicySummary,
+	resolveDisplayStatus,
+	shortModelLabel,
 	toolActivity,
 } from "./teams-ui-shared.js";
+import type { DisplayStatus, LeaderModelInfo } from "./teams-ui-shared.js";
 
 export interface WidgetDeps {
 	getTeammates(): Map<string, TeammateRpc>;
@@ -26,6 +33,7 @@ export interface WidgetDeps {
 	isDelegateMode(): boolean;
 	getActiveTeamId(): string | null;
 	getSessionTeamId(): string | null;
+	getLeaderModel(): LeaderModelInfo | null;
 }
 
 export type WidgetFactory = (tui: TUI, theme: Theme) => Component;
@@ -34,11 +42,19 @@ interface WidgetRow {
 	icon: string; // raw char (before styling)
 	iconColor: ThemeColor;
 	displayName: string;
-	statusKey: TeammateStatus;
+	statusKey: DisplayStatus;
 	pending: number;
 	completed: number;
 	tokensStr: string; // "—" for chairman
 	activityText: string;
+	/** Compact time-in-current-state string, e.g. "3m12s". Empty for leader. */
+	elapsedStr: string;
+	/** Short model label (e.g. "claude-sonnet-4-5") or null. */
+	modelLabel: string | null;
+	/** Thinking level (e.g. "high") or null. */
+	thinkingLabel: string | null;
+	/** Active task subject (if any). */
+	activeTaskSubject: string | null;
 }
 
 function shortTeamId(teamId: string): string {
@@ -96,6 +112,15 @@ export function createTeamsWidget(deps: WidgetDeps): WidgetFactory {
 					);
 				}
 
+				// ── Policy summary ──
+				const policyLines = renderPolicySummary({
+					teamConfig,
+					leaderModel: deps.getLeaderModel(),
+					theme,
+					width,
+				});
+				for (const pl of policyLines) lines.push(pl);
+
 				// ── Build row data ──
 				const cfgMembers = teamConfig?.members ?? [];
 				const cfgByName = new Map<string, TeamMember>();
@@ -116,6 +141,10 @@ export function createTeamsWidget(deps: WidgetDeps): WidgetFactory {
 						completed: leadTasks.filter((t) => t.status === "completed").length,
 						tokensStr: "\u2014",
 						activityText: "",
+						elapsedStr: "",
+						modelLabel: null,
+						thinkingLabel: null,
+						activeTaskSubject: null,
 					});
 				}
 
@@ -131,19 +160,27 @@ export function createTeamsWidget(deps: WidgetDeps): WidgetFactory {
 					for (const name of workerNames) {
 						const rpc = teammates.get(name);
 						const cfg = cfgByName.get(name);
-						const statusKey = resolveStatus(rpc, cfg);
+						const statusKey = resolveDisplayStatus(rpc, cfg);
 						const activity = tracker.get(name);
 						const owned = tasks.filter((t) => t.owner === name);
+						const activeTask = owned.find((t) => t.status === "in_progress");
+						const memberModel = getMemberModel(cfg);
+						const memberThinking = getMemberThinking(cfg);
+						const elapsed = rpc ? formatElapsed(Date.now() - rpc.lastStatusChangeAt) : "";
 
 						rows.push({
-							icon: STATUS_ICON[statusKey],
-							iconColor: STATUS_COLOR[statusKey],
+							icon: DISPLAY_STATUS_ICON[statusKey],
+							iconColor: DISPLAY_STATUS_COLOR[statusKey],
 							displayName: formatMemberDisplayName(style, name),
 							statusKey,
 							pending: owned.filter((t) => t.status === "pending").length,
 							completed: owned.filter((t) => t.status === "completed").length,
 							tokensStr: formatTokens(activity.totalTokens),
 							activityText: toolActivity(activity.currentToolName),
+							elapsedStr: elapsed,
+							modelLabel: memberModel ? shortModelLabel(memberModel) : null,
+							thinkingLabel: memberThinking,
+							activeTaskSubject: activeTask ? `#${String(activeTask.id)} ${activeTask.subject}` : null,
 						});
 					}
 
@@ -163,7 +200,7 @@ export function createTeamsWidget(deps: WidgetDeps): WidgetFactory {
 					for (const r of rows) {
 						const icon = theme.fg(r.iconColor, r.icon);
 						const styledName = theme.bold(r.displayName);
-						const statusLabel = theme.fg(STATUS_COLOR[r.statusKey], padRight(r.statusKey, 9));
+						const statusLabel = theme.fg(DISPLAY_STATUS_COLOR[r.statusKey], padRight(r.statusKey, 9));
 						const pNum = String(r.pending).padStart(pW);
 						const cNum = String(r.completed).padStart(cW);
 						const tokStr = r.tokensStr.padStart(tokW);
@@ -171,10 +208,21 @@ export function createTeamsWidget(deps: WidgetDeps): WidgetFactory {
 							"dim",
 							` \u00b7 ${pNum} pending \u00b7 ${cNum} complete \u00b7 ${tokStr} tokens`,
 						);
+						const elapsedLabel = r.elapsedStr ? " " + theme.fg("dim", r.elapsedStr) : "";
 						const actLabel = r.activityText ? "  " + theme.fg("warning", r.activityText) : "";
+						// Model + thinking badge (compact)
+						const badges: string[] = [];
+						if (r.modelLabel) badges.push(r.modelLabel);
+						if (r.thinkingLabel && r.thinkingLabel !== "off") badges.push(`t:${r.thinkingLabel}`);
+						const badgeStr = badges.length > 0 ? "  " + theme.fg("muted", badges.join(" \u00b7 ")) : "";
 
-						const row = ` ${icon} ${padRight(styledName, nameColWidth)} ${statusLabel}${cols}${actLabel}`;
+						const row = ` ${icon} ${padRight(styledName, nameColWidth)} ${statusLabel}${elapsedLabel}${cols}${actLabel}${badgeStr}`;
 						lines.push(truncateToWidth(row, width));
+						// Active task on second line (indented, only when actively working)
+						if (r.activeTaskSubject) {
+							const taskLine = `     ${theme.fg("dim", "\u2514")} ${theme.fg("warning", r.activeTaskSubject)}`;
+							lines.push(truncateToWidth(taskLine, width));
+						}
 					}
 
 					// ── Total row ──
@@ -198,10 +246,15 @@ export function createTeamsWidget(deps: WidgetDeps): WidgetFactory {
 				}
 
 				// ── Hints line ──
-				const hints = theme.fg(
-					"dim",
-					" /team widget \u00b7 /team dm <name> <msg> \u00b7 /team task list",
-				);
+				const teamDone = isTeamDone(tasks, teammates);
+				const hints = teamDone
+					? theme.fg("success", " All tasks done.") +
+						" " +
+						theme.fg("dim", "/team done \u00b7 /team task list")
+					: theme.fg(
+							"dim",
+							" /team widget \u00b7 /team dm <name> <msg> \u00b7 /team task list",
+						);
 				lines.push(truncateToWidth(hints, width));
 
 				return lines;

package/extensions/teams/worker.ts

@@ -130,16 +130,19 @@ export function runWorker(pi: ExtensionAPI): void {
 	const TeamMessageToolParamsSchema = Type.Object({
 		recipient: Type.String({ description: "Name of the comrade to message" }),
 		message: Type.String({ description: "The message to send" }),
+		urgent: Type.Optional(Type.Boolean({
+			description: "When true, the message interrupts the recipient's active turn via steering instead of waiting for idle. Use for time-sensitive coordination.",
+		})),
 	});
 	// Match the schema at compile-time.
 	type TeamMessageToolParams = Static<typeof TeamMessageToolParamsSchema>;
 	// Tool result details to match AgentToolResult<TDetails> contract.
-	type TeamMessageToolDetails = { recipient: string; timestamp: string };
+	type TeamMessageToolDetails = { recipient: string; timestamp: string; urgent: boolean };
 
 	pi.registerTool({
 		name: "team_message",
 		label: "Team Message",
-		description: "Send a message to a comrade. Use this to coordinate with peers on related tasks.",
+		description: "Send a message to a comrade. Use this to coordinate with peers on related tasks. Set urgent=true to interrupt their active turn (use sparingly — only for time-sensitive coordination).",
 		parameters: TeamMessageToolParamsSchema,
 		async execute(
 			_toolCallId,
@@ -150,12 +153,14 @@ export function runWorker(pi: ExtensionAPI): void {
 		): Promise<AgentToolResult<TeamMessageToolDetails>> {
 			const recipient = sanitizeName(params.recipient);
 			const message = params.message;
+			const isUrgent = params.urgent === true;
 			const ts = new Date().toISOString();
 			// Write to recipient's mailbox in team namespace
 			await writeToMailbox(teamDir, TEAM_MAILBOX_NS, recipient, {
 				from: agentName,
 				text: message,
 				timestamp: ts,
+				...(isUrgent ? { urgent: true } : {}),
 			});
 			// CC leader with peer_dm_sent notification
 			await writeToMailbox(teamDir, TEAM_MAILBOX_NS, leadName, {
@@ -165,13 +170,14 @@ export function runWorker(pi: ExtensionAPI): void {
 					from: agentName,
 					to: recipient,
 					summary: message.slice(0, 100),
+					urgent: isUrgent,
 					timestamp: ts,
 				}),
 				timestamp: ts,
 			});
 			return {
-				content: [{ type: "text", text: `Message sent to ${recipient}` }],
-				details: { recipient, timestamp: ts },
+				content: [{ type: "text", text: `${isUrgent ? "Urgent message" : "Message"} sent to ${recipient}` }],
+				details: { recipient, timestamp: ts, urgent: isUrgent },
 			};
 		},
 	});
@@ -330,8 +336,14 @@ export function runWorker(pi: ExtensionAPI): void {
 						pendingTaskAssignments.push(assign.taskId);
 						continue;
 					}
-					// Plain DM (or unknown structured message)
-					pendingDmTexts.push(m.text);
+
+					// Urgent DMs interrupt the active turn via steer; normal DMs queue for idle.
+					if (m.urgent && isStreaming) {
+						const prefix = `[urgent message from ${m.from}] `;
+						pi.sendUserMessage(prefix + m.text, { deliverAs: "steer" });
+					} else {
+						pendingDmTexts.push(m.text);
+					}
 				}
 
 				if (!shutdownInProgress) await maybeStartNextWork();

package/extensions/teams/worktree.ts

@@ -3,6 +3,12 @@ import * as path from "node:path";
 import { execFile } from "node:child_process";
 import { sanitizeName } from "./names.js";
 
+export type WorktreeCleanupResult = {
+	removedWorktrees: string[];
+	removedBranches: string[];
+	warnings: string[];
+};
+
 async function execGit(args: string[], opts: { cwd: string; timeoutMs?: number } ): Promise<{ stdout: string; stderr: string }> {
 	return await new Promise((resolve, reject) => {
 		execFile(
@@ -101,3 +107,140 @@ export async function ensureWorktreeCwd(opts: {
 		return { cwd: opts.leaderCwd, warnings, mode: "shared" };
 	}
 }
+
+/**
+ * Find the git repo root from a directory that may be inside a worktree.
+ * Returns null if not a git repo.
+ */
+async function findRepoRoot(cwd: string): Promise<string | null> {
+	try {
+		// --show-superproject-working-tree returns empty if not a worktree subproject.
+		// Use the commondir approach: worktrees share a common git dir with the main repo.
+		const commonDir = (await execGit(["rev-parse", "--git-common-dir"], { cwd })).stdout.trim();
+		if (commonDir && !path.isAbsolute(commonDir)) {
+			// Relative to the .git dir of the worktree — resolve upward.
+			const gitDir = (await execGit(["rev-parse", "--git-dir"], { cwd })).stdout.trim();
+			const absCommon = path.resolve(cwd, gitDir, commonDir);
+			// The common dir is the .git directory of the main repo. Its parent is the repo root.
+			return path.dirname(absCommon);
+		}
+		if (commonDir && path.isAbsolute(commonDir)) {
+			return path.dirname(commonDir);
+		}
+		// Fallback: plain repo
+		const toplevel = (await execGit(["rev-parse", "--show-toplevel"], { cwd })).stdout.trim();
+		return toplevel || null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Remove all git worktrees under `<teamDir>/worktrees/` and their associated branches.
+ *
+ * Steps for each worktree:
+ * 1. `git worktree remove --force <path>` (removes the worktree checkout)
+ * 2. `git branch -D <branch>` (removes the local branch)
+ * 3. Falls back to filesystem removal if git commands fail
+ *
+ * Also runs `git worktree prune` to clean up stale worktree bookkeeping.
+ */
+export async function cleanupWorktrees(opts: {
+	teamDir: string;
+	teamId: string;
+	/** A directory known to be in the git repo (e.g. leaderCwd). */
+	repoCwd?: string;
+}): Promise<WorktreeCleanupResult> {
+	const removedWorktrees: string[] = [];
+	const removedBranches: string[] = [];
+	const warnings: string[] = [];
+
+	const worktreesDir = path.join(opts.teamDir, "worktrees");
+	let entries: string[];
+	try {
+		entries = await fs.promises.readdir(worktreesDir);
+	} catch {
+		// No worktrees directory — nothing to do.
+		return { removedWorktrees, removedBranches, warnings };
+	}
+
+	if (entries.length === 0) {
+		return { removedWorktrees, removedBranches, warnings };
+	}
+
+	// Find the repo root. Prefer deriving from the worktree paths themselves (they belong
+	// to the repo that created them), only fall back to repoCwd when none resolve.
+	// This avoids cross-repo issues when cleanup targets a team created from a different repo.
+	let repoRoot: string | null = null;
+	for (const entry of entries) {
+		const candidate = path.join(worktreesDir, entry);
+		repoRoot = await findRepoRoot(candidate);
+		if (repoRoot) break;
+	}
+	if (!repoRoot && opts.repoCwd) {
+		repoRoot = await findRepoRoot(opts.repoCwd);
+	}
+
+	const shortTeam = sanitizeName(opts.teamId).slice(0, 12) || "team";
+
+	for (const entry of entries) {
+		const worktreePath = path.join(worktreesDir, entry);
+		const safeAgent = sanitizeName(entry);
+		const branch = `pi-teams/${shortTeam}/${safeAgent}`;
+
+		// 1. Remove worktree via git
+		if (repoRoot) {
+			try {
+				await execGit(["worktree", "remove", "--force", worktreePath], { cwd: repoRoot, timeoutMs: 30_000 });
+				removedWorktrees.push(worktreePath);
+			} catch {
+				// Git removal failed — try filesystem fallback below.
+				try {
+					await fs.promises.rm(worktreePath, { recursive: true, force: true });
+					removedWorktrees.push(worktreePath);
+				} catch (fsErr: unknown) {
+					const msg = fsErr instanceof Error ? fsErr.message : String(fsErr);
+					warnings.push(`Failed to remove worktree ${worktreePath}: ${msg}`);
+				}
+			}
+
+			// 2. Remove the associated branch
+			try {
+				await execGit(["branch", "-D", branch], { cwd: repoRoot });
+				removedBranches.push(branch);
+			} catch {
+				// Branch may not exist (shared workspace fallback) — that's fine.
+			}
+		} else {
+			// No repo root — just delete the directory.
+			try {
+				await fs.promises.rm(worktreePath, { recursive: true, force: true });
+				removedWorktrees.push(worktreePath);
+			} catch (fsErr: unknown) {
+				const msg = fsErr instanceof Error ? fsErr.message : String(fsErr);
+				warnings.push(`Failed to remove worktree directory ${worktreePath}: ${msg}`);
+			}
+		}
+	}
+
+	// 3. Prune stale worktree bookkeeping entries
+	if (repoRoot) {
+		try {
+			await execGit(["worktree", "prune"], { cwd: repoRoot });
+		} catch {
+			warnings.push("git worktree prune failed (non-fatal)");
+		}
+	}
+
+	// 4. Remove the now-empty worktrees directory itself
+	try {
+		const remaining = await fs.promises.readdir(worktreesDir);
+		if (remaining.length === 0) {
+			await fs.promises.rmdir(worktreesDir);
+		}
+	} catch {
+		// ignore — best effort
+	}
+
+	return { removedWorktrees, removedBranches, warnings };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmustier/pi-agent-teams",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Claude Code agent teams style workflow for Pi.",
   "license": "MIT",
   "author": "Thomas Mustier",
@@ -34,7 +34,8 @@
     "integration-claim-test": "tsx scripts/integration-claim-test.mts",
     "integration-spawn-overrides-test": "tsx scripts/integration-spawn-overrides-test.mts",
     "integration-hooks-remediation-test": "tsx scripts/integration-hooks-remediation-test.mts",
-    "integration-todo-test": "tsx scripts/integration-todo-test.mts"
+    "integration-todo-test": "tsx scripts/integration-todo-test.mts",
+    "integration-cleanup-test": "tsx scripts/integration-cleanup-test.mts"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",