@tmustier/pi-agent-teams 0.1.2 → 0.3.0

package/extensions/teams/teams-ui-shared.ts

@@ -0,0 +1,89 @@
+import type { ThemeColor } from "@mariozechner/pi-coding-agent";
+import { visibleWidth } from "@mariozechner/pi-tui";
+import type { TeamConfig, TeamMember } from "./team-config.js";
+import type { TeamTask } from "./task-store.js";
+import type { TeammateRpc, TeammateStatus } from "./teammate-rpc.js";
+
+// Status icon and color mapping (shared by widget + interactive panel)
+export const STATUS_ICON: Record<TeammateStatus, string> = {
+	streaming: "\u25c9",
+	idle: "\u25cf",
+	starting: "\u25cb",
+	stopped: "\u2717",
+	error: "\u2717",
+};
+
+export const STATUS_COLOR: Record<TeammateStatus, ThemeColor> = {
+	streaming: "accent",
+	idle: "success",
+	starting: "muted",
+	stopped: "dim",
+	error: "error",
+};
+
+export const TOOL_VERB: Record<string, string> = {
+	read: "reading\u2026",
+	edit: "editing\u2026",
+	write: "writing\u2026",
+	grep: "searching\u2026",
+	glob: "finding files\u2026",
+	bash: "running\u2026",
+	task: "delegating\u2026",
+	webfetch: "fetching\u2026",
+	websearch: "searching web\u2026",
+};
+
+export function toolVerb(toolName: string): string {
+	const key = toolName.toLowerCase();
+	return TOOL_VERB[key] ?? `${toolName}\u2026`;
+}
+
+export function toolActivity(toolName: string | null): string {
+	if (!toolName) return "";
+	return toolVerb(toolName);
+}
+
+export function padRight(str: string, targetWidth: number): string {
+	const w = visibleWidth(str);
+	return w >= targetWidth ? str : str + " ".repeat(targetWidth - w);
+}
+
+export function resolveStatus(rpc: TeammateRpc | undefined, cfg: TeamMember | undefined): TeammateStatus {
+	if (rpc) return rpc.status;
+	return cfg?.status === "online" ? "idle" : "stopped";
+}
+
+export function formatTokens(n: number): string {
+	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+	if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
+	return String(n);
+}
+
+/**
+ * Compute the set of worker names that should be visible in the UI.
+ *
+ * Rule: show any worker that is:
+ * - currently spawned/known as a teammate RPC
+ * - online in team config
+ * - owning an in-progress task (even if RPC is disconnected)
+ */
+export function getVisibleWorkerNames(opts: {
+	teammates: ReadonlyMap<string, TeammateRpc>;
+	teamConfig: TeamConfig | null;
+	tasks: readonly TeamTask[];
+}): string[] {
+	const { teammates, teamConfig, tasks } = opts;
+	const leadName = teamConfig?.leadName;
+	const cfgMembers = teamConfig?.members ?? [];
+
+	const names = new Set<string>();
+	for (const name of teammates.keys()) names.add(name);
+	for (const m of cfgMembers) {
+		if (m.role === "worker" && m.status === "online") names.add(m.name);
+	}
+	for (const t of tasks) {
+		if (t.owner && t.owner !== leadName && t.status === "in_progress") names.add(t.owner);
+	}
+
+	return Array.from(names).sort();
+}

package/extensions/teams/teams-widget.ts

@@ -0,0 +1,182 @@
+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 { 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,
+	formatTokens,
+	getVisibleWorkerNames,
+	padRight,
+	resolveStatus,
+	toolActivity,
+} from "./teams-ui-shared.js";
+
+export interface WidgetDeps {
+	getTeammates(): Map<string, TeammateRpc>;
+	getTracker(): ActivityTracker;
+	getTasks(): TeamTask[];
+	getTeamConfig(): TeamConfig | null;
+	getStyle(): TeamsStyle;
+	isDelegateMode(): boolean;
+}
+
+export type WidgetFactory = (tui: TUI, theme: Theme) => Component;
+
+interface WidgetRow {
+	icon: string; // raw char (before styling)
+	iconColor: ThemeColor;
+	displayName: string;
+	statusKey: TeammateStatus;
+	pending: number;
+	completed: number;
+	tokensStr: string; // "—" for chairman
+	activityText: string;
+}
+
+export function createTeamsWidget(deps: WidgetDeps): WidgetFactory {
+	return (_tui: TUI, theme: Theme): Component => {
+		return {
+			render(width: number): string[] {
+				const teammates = deps.getTeammates();
+				const tracker = deps.getTracker();
+				const tasks = deps.getTasks();
+				const teamConfig = deps.getTeamConfig();
+				const style = deps.getStyle();
+				const strings = getTeamsStrings(style);
+				const delegateMode = deps.isDelegateMode();
+
+				// Hide when no active team state
+				const hasOnlineMembers = (teamConfig?.members ?? []).some(
+					(m) => m.role === "worker" && m.status === "online",
+				);
+				if (teammates.size === 0 && tasks.length === 0 && !hasOnlineMembers) {
+					return [];
+				}
+
+				const lines: string[] = [];
+
+				// ── Header line ──
+				let header = " " + theme.bold(theme.fg("accent", "Teams"));
+				if (delegateMode) header += " " + theme.fg("warning", "[delegate]");
+				lines.push(truncateToWidth(header, width));
+
+				// ── Build row data ──
+				const cfgMembers = teamConfig?.members ?? [];
+				const cfgByName = new Map<string, TeamMember>();
+				for (const m of cfgMembers) cfgByName.set(m.name, m);
+
+				const rows: WidgetRow[] = [];
+
+				// Chairman row (always first when team is active)
+				const leadName = teamConfig?.leadName;
+				if (leadName) {
+					const leadTasks = tasks.filter((t) => t.owner === leadName);
+					rows.push({
+						icon: "\u25c6",
+						iconColor: "accent",
+						displayName: strings.leaderTitle,
+						statusKey: "idle",
+						pending: leadTasks.filter((t) => t.status === "pending").length,
+						completed: leadTasks.filter((t) => t.status === "completed").length,
+						tokensStr: "\u2014",
+						activityText: "",
+					});
+				}
+
+				const workerNames = getVisibleWorkerNames({ teammates, teamConfig, tasks });
+				if (workerNames.length === 0 && rows.length === 0) {
+					lines.push(
+						truncateToWidth(
+							" " + theme.fg("dim", `(no ${strings.memberTitle.toLowerCase()}s)  /team spawn <name>`),
+							width,
+						),
+					);
+				} else {
+					for (const name of workerNames) {
+						const rpc = teammates.get(name);
+						const cfg = cfgByName.get(name);
+						const statusKey = resolveStatus(rpc, cfg);
+						const activity = tracker.get(name);
+						const owned = tasks.filter((t) => t.owner === name);
+
+						rows.push({
+							icon: STATUS_ICON[statusKey],
+							iconColor: 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),
+						});
+					}
+
+					// ── Compute column widths ──
+					const totalPending = tasks.filter((t) => t.status === "pending").length;
+					const totalCompleted = tasks.filter((t) => t.status === "completed").length;
+					let totalTokensRaw = 0;
+					for (const name of workerNames) totalTokensRaw += tracker.get(name).totalTokens;
+					const totalTokensStr = formatTokens(totalTokensRaw);
+
+					const nameColWidth = Math.max(...rows.map((r) => visibleWidth(r.displayName)));
+					const pW = Math.max(...rows.map((r) => String(r.pending).length), String(totalPending).length);
+					const cW = Math.max(...rows.map((r) => String(r.completed).length), String(totalCompleted).length);
+					const tokW = Math.max(...rows.map((r) => r.tokensStr.length), totalTokensStr.length);
+
+					// ── Render rows ──
+					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 pNum = String(r.pending).padStart(pW);
+						const cNum = String(r.completed).padStart(cW);
+						const tokStr = r.tokensStr.padStart(tokW);
+						const cols = theme.fg(
+							"dim",
+							` \u00b7 ${pNum} pending \u00b7 ${cNum} complete \u00b7 ${tokStr} tokens`,
+						);
+						const actLabel = r.activityText ? "  " + theme.fg("warning", r.activityText) : "";
+
+						const row = ` ${icon} ${padRight(styledName, nameColWidth)} ${statusLabel}${cols}${actLabel}`;
+						lines.push(truncateToWidth(row, width));
+					}
+
+					// ── Total row ──
+					const sepLine = " " + theme.fg("dim", "\u2500".repeat(Math.max(0, width - 2)));
+					lines.push(truncateToWidth(sepLine, width));
+
+					const totalLabel = theme.bold("Total");
+					const totalTaskCount = totalPending + totalCompleted;
+					const pct = totalTaskCount > 0 ? Math.round((totalCompleted / totalTaskCount) * 100) : 0;
+					const pctLabel = theme.fg("success", padRight(`${pct}%`, 9));
+					const tpNum = String(totalPending).padStart(pW);
+					const tcNum = String(totalCompleted).padStart(cW);
+					const ttokStr = totalTokensStr.padStart(tokW);
+					const totalSuffix = theme.fg(
+						"muted",
+						` \u00b7 ${tpNum} pending \u00b7 ${tcNum} complete \u00b7 ${ttokStr} tokens`,
+					);
+					// nameColWidth + 4 = " ◆ " + name; then " " + pctLabel fills the status column
+					const totalRow = ` ${padRight(totalLabel, nameColWidth + 3)} ${pctLabel}${totalSuffix}`;
+					lines.push(truncateToWidth(totalRow, width));
+				}
+
+				// ── Hints line ──
+				const hints = theme.fg(
+					"dim",
+					" /team widget \u00b7 /team dm <name> <msg> \u00b7 /team task list",
+				);
+				lines.push(truncateToWidth(hints, width));
+
+				return lines;
+			},
+			invalidate() {},
+		};
+	};
+}

package/extensions/teams/worker.ts

@@ -1,8 +1,19 @@
-import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { AgentMessage, AgentToolResult } from "@mariozechner/pi-agent-core";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
+import { Type, type Static } from "@sinclair/typebox";
 import { randomUUID } from "node:crypto";
 import { popUnreadMessages, writeToMailbox } from "./mailbox.js";
+import { sanitizeName } from "./names.js";
+import { getTeamsStyleFromEnv, type TeamsStyle, getTeamsStrings } from "./teams-style.js";
+import {
+	TEAM_MAILBOX_NS,
+	isAbortRequestMessage,
+	isPlanApprovedMessage,
+	isPlanRejectedMessage,
+	isSetSessionNameMessage,
+	isShutdownRequestMessage,
+	isTaskAssignmentMessage,
+} from "./protocol.js";
 import { getTeamDir } from "./paths.js";
 import { ensureTeamConfig, setMemberStatus, upsertMember } from "./team-config.js";
 import {
@@ -16,31 +27,27 @@ import {
 	type TeamTask,
 } from "./task-store.js";
 
-const TEAM_MAILBOX_NS = "team";
-
 function sleep(ms: number): Promise<void> {
 	return new Promise((r) => setTimeout(r, ms));
 }
 
-function sanitize(name: string): string {
-	return name.replace(/[^a-zA-Z0-9_-]/g, "-");
-}
-
 function teamDirFromEnv(): {
 	teamId: string;
 	teamDir: string;
 	taskListId: string;
 	agentName: string;
 	leadName: string;
+	style: TeamsStyle;
 	autoClaim: boolean;
 } | null {
 	const teamId = process.env.PI_TEAMS_TEAM_ID;
 	const agentNameRaw = process.env.PI_TEAMS_AGENT_NAME;
 	if (!teamId || !agentNameRaw) return null;
 
-	const agentName = sanitize(agentNameRaw);
+	const agentName = sanitizeName(agentNameRaw);
 	const taskListId = process.env.PI_TEAMS_TASK_LIST_ID ?? teamId;
-	const leadName = sanitize(process.env.PI_TEAMS_LEAD_NAME ?? "team-lead");
+	const style = getTeamsStyleFromEnv(process.env);
+	const leadName = sanitizeName(process.env.PI_TEAMS_LEAD_NAME ?? "team-lead");
 	const autoClaim = (process.env.PI_TEAMS_AUTO_CLAIM ?? "1") === "1";
 
 	return {
@@ -49,32 +56,57 @@ function teamDirFromEnv(): {
 		taskListId,
 		agentName,
 		leadName,
+		style,
 		autoClaim,
 	};
 }
 
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function hasProperty<K extends string>(value: unknown, key: K): value is Record<K, unknown> & Record<string, unknown> {
+	return isObjectRecord(value) && key in value;
+}
+
+function hasStringProperty<K extends string>(value: unknown, key: K): value is Record<K, string> & Record<string, unknown> {
+	return isObjectRecord(value) && typeof value[key] === "string";
+}
+
+type AssistantMessageWithContent = Record<"role", "assistant"> & Record<"content", unknown> & Record<string, unknown>;
+
+function isAssistantMessageWithContent(message: unknown): message is AssistantMessageWithContent {
+	return hasStringProperty(message, "role") && message.role === "assistant" && hasProperty(message, "content");
+}
+
+type TextBlock = { type: "text"; text: string };
+
+function isTextBlock(block: unknown): block is TextBlock {
+	return hasStringProperty(block, "type") && block.type === "text" && hasStringProperty(block, "text");
+}
+
 function extractLastAssistantText(messages: AgentMessage[]): string {
-	const assistant = messages.filter((m: any) => m && typeof m === "object" && m.role === "assistant");
-	const last: any = assistant[assistant.length - 1];
+	const assistant = messages.filter((m) => isAssistantMessageWithContent(m));
+	const last = assistant.at(-1);
 	if (!last) return "";
 
 	const content = last.content;
 	if (typeof content === "string") return content;
 	if (Array.isArray(content)) {
-		return content
-			.filter((c) => c && typeof c === "object" && c.type === "text" && typeof (c as any).text === "string")
-			.map((c: any) => c.text)
-			.join("");
+		return content.filter((c) => isTextBlock(c)).map((c) => c.text).join("");
 	}
 	return "";
 }
 
-function buildTaskPrompt(agentName: string, task: TeamTask, planOnly = false): string {
+function buildTaskPrompt(style: TeamsStyle, agentName: string, task: TeamTask, planOnly = false): string {
+	const strings = getTeamsStrings(style);
 	const footer = planOnly
 		? "Produce a detailed implementation plan only. Do NOT make any changes or implement anything yet. Your plan will be reviewed before you can proceed."
 		: "Do the work now. When finished, reply with a concise summary and any key outputs.";
+
+	const actor = style === "soviet" ? strings.memberTitle.toLowerCase() : "teammate";
 	return [
-		`You are teammate '${agentName}'.`,
+		`You are ${actor} '${agentName}'.`,
 		`You have been assigned task #${task.id}.`,
 		`Subject: ${task.subject}`,
 		"",
@@ -84,124 +116,36 @@ function buildTaskPrompt(agentName: string, task: TeamTask, planOnly = false): s
 	].join("\n");
 }
 
-function isTaskAssignmentMessage(text: string): { taskId: string; subject?: string; description?: string; assignedBy?: string } | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "task_assignment") return null;
-		if (typeof obj.taskId !== "string") return null;
-		return {
-			taskId: obj.taskId,
-			subject: typeof obj.subject === "string" ? obj.subject : undefined,
-			description: typeof obj.description === "string" ? obj.description : undefined,
-			assignedBy: typeof obj.assignedBy === "string" ? obj.assignedBy : undefined,
-		};
-	} catch {
-		return null;
-	}
-}
-
-function isShutdownRequestMessage(text: string): { requestId: string; from?: string; reason?: string; timestamp?: string } | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "shutdown_request") return null;
-		if (typeof obj.requestId !== "string") return null;
-		return {
-			requestId: obj.requestId,
-			from: typeof obj.from === "string" ? obj.from : undefined,
-			reason: typeof obj.reason === "string" ? obj.reason : undefined,
-			timestamp: typeof obj.timestamp === "string" ? obj.timestamp : undefined,
-		};
-	} catch {
-		return null;
-	}
-}
-
-function isSetSessionNameMessage(text: string): { name: string } | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "set_session_name") return null;
-		if (typeof obj.name !== "string") return null;
-		return { name: obj.name };
-	} catch {
-		return null;
-	}
-}
-
-function isAbortRequestMessage(
-	text: string,
-): { requestId: string; from?: string; taskId?: string; reason?: string; timestamp?: string } | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "abort_request") return null;
-		if (typeof obj.requestId !== "string") return null;
-		return {
-			requestId: obj.requestId,
-			from: typeof obj.from === "string" ? obj.from : undefined,
-			taskId: typeof obj.taskId === "string" ? obj.taskId : undefined,
-			reason: typeof obj.reason === "string" ? obj.reason : undefined,
-			timestamp: typeof obj.timestamp === "string" ? obj.timestamp : undefined,
-		};
-	} catch {
-		return null;
-	}
-}
-
-function isPlanApprovedMessage(text: string): { requestId: string; from: string; timestamp: string } | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "plan_approved") return null;
-		if (typeof obj.requestId !== "string" || typeof obj.from !== "string") return null;
-		return {
-			requestId: obj.requestId,
-			from: obj.from,
-			timestamp: typeof obj.timestamp === "string" ? obj.timestamp : "",
-		};
-	} catch {
-		return null;
-	}
-}
-
-function isPlanRejectedMessage(
-	text: string,
-): { requestId: string; from: string; feedback: string; timestamp: string } | null {
-	try {
-		const obj = JSON.parse(text);
-		if (!obj || typeof obj !== "object") return null;
-		if (obj.type !== "plan_rejected") return null;
-		if (typeof obj.requestId !== "string" || typeof obj.from !== "string") return null;
-		return {
-			requestId: obj.requestId,
-			from: obj.from,
-			feedback: typeof obj.feedback === "string" ? obj.feedback : "",
-			timestamp: typeof obj.timestamp === "string" ? obj.timestamp : "",
-		};
-	} catch {
-		return null;
-	}
-}
-
+// Message parsers are shared with the leader implementation.
 export function runWorker(pi: ExtensionAPI): void {
 	const env = teamDirFromEnv();
 	if (!env) return;
 
-	const { teamId, teamDir, taskListId, agentName, leadName, autoClaim } = env;
+	const { teamId, teamDir, taskListId, agentName, leadName, style, autoClaim } = env;
+
+	const TeamMessageToolParamsSchema = Type.Object({
+		recipient: Type.String({ description: "Name of the comrade to message" }),
+		message: Type.String({ description: "The message to send" }),
+	});
+	// 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 };
 
 	pi.registerTool({
 		name: "team_message",
 		label: "Team Message",
-		description: "Send a message to a teammate. Use this to coordinate with peers on related tasks.",
-		parameters: Type.Object({
-			recipient: Type.String({ description: "Name of the teammate to message" }),
-			message: Type.String({ description: "The message to send" }),
-		}),
-		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-			const recipient = sanitize((params as any).recipient);
-			const message = (params as any).message as string;
+		description: "Send a message to a comrade. Use this to coordinate with peers on related tasks.",
+		parameters: TeamMessageToolParamsSchema,
+		async execute(
+			_toolCallId,
+			params: TeamMessageToolParams,
+			_signal,
+			_onUpdate,
+			_ctx,
+		): Promise<AgentToolResult<TeamMessageToolDetails>> {
+			const recipient = sanitizeName(params.recipient);
+			const message = params.message;
 			const ts = new Date().toISOString();
 			// Write to recipient's mailbox in team namespace
 			await writeToMailbox(teamDir, TEAM_MAILBOX_NS, recipient, {
@@ -221,7 +165,10 @@ export function runWorker(pi: ExtensionAPI): void {
 				}),
 				timestamp: ts,
 			});
-			return { content: [{ type: "text", text: `Message sent to ${recipient}` }] };
+			return {
+				content: [{ type: "text", text: `Message sent to ${recipient}` }],
+				details: { recipient, timestamp: ts },
+			};
 		},
 	});
 
@@ -388,7 +335,8 @@ export function runWorker(pi: ExtensionAPI): void {
 				// ignore polling errors
 			}
 
-			await sleep(350);
+			// Add a little jitter to avoid all workers polling/claiming in lock-step.
+			await sleep(350 + Math.floor(Math.random() * 200));
 		}
 	};
 
@@ -404,7 +352,8 @@ export function runWorker(pi: ExtensionAPI): void {
 			// 1) Assigned tasks
 			const requeue: string[] = [];
 			while (pendingTaskAssignments.length) {
-				const taskId = pendingTaskAssignments.shift()!;
+				const taskId = pendingTaskAssignments.shift();
+				if (!taskId) break;
 				const task = await getTask(teamDir, taskListId, taskId);
 				if (!task) continue;
 				if (task.owner !== agentName) continue;
@@ -421,7 +370,7 @@ export function runWorker(pi: ExtensionAPI): void {
 
 				currentTaskId = taskId;
 				isStreaming = true; // optimistic; agent_start will follow
-				pi.sendUserMessage(buildTaskPrompt(agentName, task, planMode && !planApproved));
+				pi.sendUserMessage(buildTaskPrompt(style, agentName, task, planMode && !planApproved));
 				pendingTaskAssignments = [...requeue, ...pendingTaskAssignments];
 				return;
 			}
@@ -433,7 +382,7 @@ export function runWorker(pi: ExtensionAPI): void {
 				pendingDmTexts = [];
 				isStreaming = true;
 				pi.sendUserMessage([
-					{ type: "text", text: "You have received teammate message(s):" },
+					{ type: "text", text: "You have received comrade message(s):" },
 					{ type: "text", text },
 				]);
 				return;
@@ -441,11 +390,15 @@ export function runWorker(pi: ExtensionAPI): void {
 
 			// 3) Auto-claim
 			if (autoClaim) {
+				// Small randomized delay improves fairness (reduces one fast worker hogging tasks)
+				// and reduces lock contention when many workers become idle simultaneously.
+				await sleep(Math.floor(Math.random() * 250));
+
 				const claimed = await claimNextAvailableTask(teamDir, taskListId, agentName, { checkAgentBusy: true });
 				if (claimed) {
 					currentTaskId = claimed.id;
 					isStreaming = true;
-					pi.sendUserMessage(buildTaskPrompt(agentName, claimed, planMode && !planApproved));
+					pi.sendUserMessage(buildTaskPrompt(style, agentName, claimed, planMode && !planApproved));
 					return;
 				}
 			}
@@ -459,7 +412,16 @@ export function runWorker(pi: ExtensionAPI): void {
 		completedStatus?: "completed" | "failed",
 		failureReason?: string,
 	) => {
-		const payload: any = {
+		type IdleNotificationPayload = {
+			type: "idle_notification";
+			from: string;
+			timestamp: string;
+			completedTaskId?: string;
+			completedStatus?: "completed" | "failed";
+			failureReason?: string;
+		};
+
+		const payload: IdleNotificationPayload = {
 			type: "idle_notification",
 			from: agentName,
 			timestamp: new Date().toISOString(),
@@ -494,7 +456,7 @@ export function runWorker(pi: ExtensionAPI): void {
 
 		// Register ourselves in the shared team config so manual tmux workers are discoverable.
 		try {
-			const cfg = await ensureTeamConfig(teamDir, { teamId, taskListId, leadName });
+			const cfg = await ensureTeamConfig(teamDir, { teamId, taskListId, leadName, style });
 			const now = new Date().toISOString();
 			if (!cfg.members.some((m) => m.name === agentName)) {
 				await upsertMember(teamDir, {
@@ -541,7 +503,7 @@ export function runWorker(pi: ExtensionAPI): void {
 		// Plan submission: if in plan mode and not yet approved, send plan to leader for review
 		// Only do this when we're working on a task and haven't already requested approval.
 		if (planMode && !planApproved && currentTaskId && !planRequestId) {
-			const lastAssistantText = extractLastAssistantText(event.messages as AgentMessage[]);
+			const lastAssistantText = extractLastAssistantText(event.messages);
 			const reqId = randomUUID();
 			planRequestId = reqId;
 			const timestamp = new Date().toISOString();
@@ -570,7 +532,7 @@ export function runWorker(pi: ExtensionAPI): void {
 
 		try {
 			if (taskId) {
-				const rawResult = extractLastAssistantText(event.messages as AgentMessage[]);
+				const rawResult = extractLastAssistantText(event.messages);
 				const trimmed = rawResult.trim();
 				const abortedByRequest = abortTaskId === taskId;
 				const aborted = abortedByRequest || trimmed.length === 0;

package/extensions/teams/worktree.ts

@@ -1,10 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { execFile } from "node:child_process";
-
-function sanitize(name: string): string {
-	return name.replace(/[^a-zA-Z0-9_-]/g, "-");
-}
+import { sanitizeName } from "./names.js";
 
 async function execGit(args: string[], opts: { cwd: string; timeoutMs?: number } ): Promise<{ stdout: string; stderr: string }> {
 	return await new Promise((resolve, reject) => {
@@ -71,8 +68,8 @@ export async function ensureWorktreeCwd(opts: {
 		// ignore status errors
 	}
 
-	const safeAgent = sanitize(opts.agentName);
-	const shortTeam = sanitize(opts.teamId).slice(0, 12) || "team";
+	const safeAgent = sanitizeName(opts.agentName);
+	const shortTeam = sanitizeName(opts.teamId).slice(0, 12) || "team";
 	const branch = `pi-teams/${shortTeam}/${safeAgent}`;
 
 	const worktreesDir = path.join(opts.teamDir, "worktrees");
@@ -88,7 +85,7 @@ export async function ensureWorktreeCwd(opts: {
 		// Create worktree + new branch from HEAD
 		await execGit(["worktree", "add", "-b", branch, worktreePath, "HEAD"], { cwd: repoRoot, timeoutMs: 120_000 });
 		return { cwd: worktreePath, warnings, mode: "worktree" };
-	} catch (err: any) {
+	} catch (err: unknown) {
 		const msg = err instanceof Error ? err.message : String(err);
 		// If the branch already exists (e.g. previous run), try adding worktree using the existing branch.
 		if (msg.includes("already exists") || msg.includes("is already checked out")) {