@tmustier/pi-agent-teams 0.4.0-beta.3 → 0.5.0

package/extensions/teams/leader-teams-tool.ts

@@ -9,6 +9,12 @@ import { getTeamDir } from "./paths.js";
 import { TEAM_MAILBOX_NS, taskAssignmentPayload } from "./protocol.js";
 import { ensureTeamConfig, setMemberStatus, updateTeamHooksPolicy } from "./team-config.js";
 import { getTeamsNamingRules, getTeamsStyleFromEnv, type TeamsStyle, formatMemberDisplayName, getTeamsStrings } from "./teams-style.js";
+import {
+	formatProviderModel,
+	isDeprecatedTeammateModelId,
+	resolveTeammateModelSelection,
+	type TeammateModelSource,
+} from "./model-policy.js";
 import {
 	getTeamsHookFailureAction,
 	getTeamsHookFollowupOwnerPolicy,
@@ -27,10 +33,25 @@ import {
 	updateTask,
 } from "./task-store.js";
 import type { TeammateRpc } from "./teammate-rpc.js";
+import type { ActivityTracker } from "./activity-tracker.js";
+import {
+	resolveDisplayStatus,
+	formatElapsed,
+	lastMessageSummary,
+	formatTokens,
+	toolActivity,
+} from "./teams-ui-shared.js";
 import type { ContextMode, WorkspaceMode, SpawnTeammateFn } from "./spawn-types.js";
+import type { DelegationTracker } from "./leader-inbox.js";
 
 type TeamsToolDelegateTask = { text: string; assignee?: string };
 
+function describeModelSource(source: TeammateModelSource): string {
+	if (source === "override") return "override";
+	if (source === "inherit_leader") return "leader";
+	return "teammate-default";
+}
+
 const TeamsActionSchema = StringEnum(
 	[
 		"delegate",
@@ -44,13 +65,17 @@ const TeamsActionSchema = StringEnum(
 		"message_broadcast",
 		"message_steer",
 		"member_spawn",
+		"member_status",
 		"member_shutdown",
 		"member_kill",
 		"member_prune",
+		"team_done",
 		"plan_approve",
 		"plan_reject",
 		"hooks_policy_get",
 		"hooks_policy_set",
+		"model_policy_get",
+		"model_policy_check",
 	] as const,
 	{
 		description: "Teams tool action.",
@@ -101,7 +126,7 @@ const TeamsToolParamsSchema = Type.Object({
 	message: Type.Optional(Type.String({ description: "Message body for messaging actions." })),
 	reason: Type.Optional(Type.String({ description: "Optional reason for lifecycle actions." })),
 	feedback: Type.Optional(Type.String({ description: "Feedback for action=plan_reject." })),
-	all: Type.Optional(Type.Boolean({ description: "For member_shutdown/member_prune, apply to all workers." })),
+	all: Type.Optional(Type.Boolean({ description: "For member_shutdown/member_prune: apply to all workers. For team_done: force even with in-progress tasks." })),
 	planRequired: Type.Optional(Type.Boolean({ description: "For member_spawn, start worker in plan-required mode." })),
 	teammates: Type.Optional(
 		Type.Array(Type.String(), {
@@ -131,6 +156,7 @@ const TeamsToolParamsSchema = Type.Object({
 	),
 	hookFollowupOwner: Type.Optional(TeamsHookFollowupOwnerSchema),
 	hooksPolicyReset: Type.Optional(Type.Boolean({ description: "For hooks_policy_set, clear team-level overrides before applying fields." })),
+	urgent: Type.Optional(Type.Boolean({ description: "For message_dm/message_broadcast: interrupt the recipient's active turn via steering instead of waiting for idle. Use sparingly." })),
 });
 
 type TeamsToolParamsType = Static<typeof TeamsToolParamsSchema>;
@@ -141,18 +167,25 @@ export function registerTeamsTool(opts: {
 	spawnTeammate: SpawnTeammateFn;
 	getTeamId: (ctx: Parameters<SpawnTeammateFn>[0]) => string;
 	getTaskListId: () => string | null;
+	getTracker: () => ActivityTracker;
+	getTeamConfig: () => import("./team-config.js").TeamConfig | null;
 	refreshTasks: () => Promise<void>;
 	renderWidget: () => void;
+	hideWidget: () => void;
+	stopAllTeammates: (reason: string) => Promise<void>;
 	pendingPlanApprovals: Map<string, { requestId: string; name: string; taskId?: string }>;
+	delegationTracker?: DelegationTracker;
 }): void {
-	const { pi, teammates, spawnTeammate, getTeamId, getTaskListId, refreshTasks, renderWidget, pendingPlanApprovals } = opts;
+	const { pi, teammates, spawnTeammate, getTeamId, getTaskListId, getTracker, getTeamConfig: getTeamCfg, refreshTasks, renderWidget, hideWidget, stopAllTeammates, pendingPlanApprovals, delegationTracker } = opts;
 
 	pi.registerTool({
 		name: "teams",
 		label: "Teams",
 		description: [
 			"Spawn comrade agents and delegate tasks. Each comrade is a child Pi process that executes work autonomously and reports back.",
-			"You can also mutate existing tasks (assign, unassign, set status, dependencies), send team messages, run teammate lifecycle actions, and manage hooks remediation policy without user slash commands.",
+			"You can also mutate existing tasks (assign, unassign, set status, dependencies), send team messages, run teammate lifecycle actions, and manage hooks/model policy without user slash commands.",
+			"Use member_status (with optional name) to get real-time worker state: activity, time in state, stall detection, tool use, tokens, and last message summary.",
+			"Use team_done to end a team run when all tasks are complete (stops teammates, hides widget).",
 			"Provide a list of tasks with optional assignees; comrades are spawned automatically and assigned round-robin if unspecified.",
 			"Options: contextMode=branch (clone session context), workspaceMode=worktree (git worktree isolation).",
 			"Optional overrides: model='<provider>/<modelId>' and thinking (off|minimal|low|medium|high|xhigh).",
@@ -369,14 +402,17 @@ export function registerTeamsTool(opts: {
 					};
 				}
 				const name = sanitizeName(nameRaw);
+				const isUrgent = params.urgent === true;
 				await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
 					from: cfg.leadName,
 					text: message,
 					timestamp: new Date().toISOString(),
+					...(isUrgent ? { urgent: true } : {}),
 				});
+				const verb = isUrgent ? "Urgent DM" : "DM";
 				return {
-					content: [{ type: "text", text: `DM queued for ${formatMemberDisplayName(style, name)}` }],
-					details: { action, teamId, name, mailboxNamespace: TEAM_MAILBOX_NS },
+					content: [{ type: "text", text: `${verb} queued for ${formatMemberDisplayName(style, name)}` }],
+					details: { action, teamId, name, urgent: isUrgent, mailboxNamespace: TEAM_MAILBOX_NS },
 				};
 			}
 
@@ -404,6 +440,7 @@ export function registerTeamsTool(opts: {
 						details: { action, recipients: [] },
 					};
 				}
+				const isUrgent = params.urgent === true;
 				const ts = new Date().toISOString();
 				await Promise.all(
 					names.map((name) =>
@@ -411,12 +448,14 @@ export function registerTeamsTool(opts: {
 							from: cfg.leadName,
 							text: message,
 							timestamp: ts,
+							...(isUrgent ? { urgent: true } : {}),
 						}),
 					),
 				);
+				const verb = isUrgent ? "Urgent broadcast" : "Broadcast";
 				return {
-					content: [{ type: "text", text: `Broadcast queued for ${names.length} ${strings.memberTitle.toLowerCase()}(s): ${names.map((n) => formatMemberDisplayName(style, n)).join(", ")}` }],
-					details: { action, teamId, recipients: names, mailboxNamespace: TEAM_MAILBOX_NS },
+					content: [{ type: "text", text: `${verb} queued for ${names.length} ${strings.memberTitle.toLowerCase()}(s): ${names.map((n) => formatMemberDisplayName(style, n)).join(", ")}` }],
+					details: { action, teamId, recipients: names, urgent: isUrgent, mailboxNamespace: TEAM_MAILBOX_NS },
 				};
 			}
 
@@ -485,11 +524,152 @@ export function registerTeamsTool(opts: {
 				const lines: string[] = [
 					`Spawned ${formatMemberDisplayName(style, res.name)} (${res.mode}/${res.workspaceMode})`,
 				];
+				if (res.model) lines.push(`model: ${res.model}`);
+				if (res.thinking) lines.push(`thinking: ${res.thinking}`);
 				if (res.note) lines.push(`note: ${res.note}`);
 				for (const w of res.warnings) lines.push(`warning: ${w}`);
 				return {
 					content: [{ type: "text", text: lines.join("\n") }],
-					details: { action, teamId, name: res.name, mode: res.mode, workspaceMode: res.workspaceMode, warnings: res.warnings },
+					details: {
+						action,
+						teamId,
+						name: res.name,
+						mode: res.mode,
+						workspaceMode: res.workspaceMode,
+						model: res.model,
+						thinking: res.thinking,
+						warnings: res.warnings,
+					},
+				};
+			}
+
+			if (action === "member_status") {
+				const nameRaw = params.name?.trim();
+				const name = sanitizeName(nameRaw ?? "");
+				const teamCfg = getTeamCfg();
+
+				// If no name given, return summary for all workers.
+				if (!name) {
+					const allTasks = await listTasks(teamDir, effectiveTlId);
+					const tracker = getTracker();
+					const cfgMembers = teamCfg?.members ?? [];
+					const cfgByName = new Map<string, (typeof cfgMembers)[number]>();
+					for (const m of cfgMembers) cfgByName.set(m.name, m);
+
+					const workerNames = new Set<string>();
+					for (const n of teammates.keys()) workerNames.add(n);
+					for (const m of cfgMembers) {
+						if (m.role === "worker" && m.status === "online") workerNames.add(m.name);
+					}
+					for (const t of allTasks) {
+						if (t.owner && t.owner !== (teamCfg?.leadName ?? "") && t.status === "in_progress") workerNames.add(t.owner);
+					}
+
+					if (workerNames.size === 0) {
+						return {
+							content: [{ type: "text", text: `No ${strings.memberTitle.toLowerCase()}s to report on` }],
+							details: { action, teamId, workers: [] },
+						};
+					}
+
+					const workers: Array<Record<string, unknown>> = [];
+					const lines: string[] = [];
+					for (const n of Array.from(workerNames).sort()) {
+						const rpc = teammates.get(n);
+						const memberCfg = cfgByName.get(n);
+						const displayStatus = resolveDisplayStatus(rpc, memberCfg);
+						const activity = tracker.get(n);
+						const elapsed = rpc ? formatElapsed(Date.now() - rpc.lastStatusChangeAt) : "";
+						const noEventFor = rpc ? formatElapsed(Date.now() - rpc.lastEventAt) : "";
+						const currentTool = toolActivity(activity.currentToolName);
+						const msgPreview = lastMessageSummary(rpc, 80);
+						const model = memberCfg?.meta?.["model"];
+
+						lines.push(`${formatMemberDisplayName(style, n)}: ${displayStatus} ${elapsed}${currentTool ? ` (${currentTool})` : ""} · ${formatTokens(activity.totalTokens)} tokens`);
+						if (msgPreview) lines.push(`  last: ${msgPreview}`);
+
+						workers.push({
+							name: n,
+							status: displayStatus,
+							transportStatus: rpc?.status ?? "unknown",
+							timeInState: elapsed,
+							lastEventAgo: noEventFor,
+							currentTool: activity.currentToolName,
+							toolUseCount: activity.toolUseCount,
+							turnCount: activity.turnCount,
+							totalTokens: activity.totalTokens,
+							model: typeof model === "string" ? model : undefined,
+						});
+					}
+
+					return {
+						content: [{ type: "text", text: lines.join("\n") }],
+						details: { action, teamId, workers },
+					};
+				}
+
+				// Single worker status
+				const rpc = teammates.get(name);
+				const memberCfg = (teamCfg?.members ?? []).find((m) => m.name === name);
+				if (!rpc && !memberCfg) {
+					return {
+						content: [{ type: "text", text: `Unknown ${strings.memberTitle.toLowerCase()}: ${name}` }],
+						details: { action, name },
+					};
+				}
+
+				const displayStatus = resolveDisplayStatus(rpc, memberCfg);
+				const tracker = getTracker();
+				const activity = tracker.get(name);
+				const elapsed = rpc ? formatElapsed(Date.now() - rpc.lastStatusChangeAt) : "";
+				const noEventFor = rpc ? formatElapsed(Date.now() - rpc.lastEventAt) : "";
+				const currentTool = toolActivity(activity.currentToolName);
+				const msgPreview = lastMessageSummary(rpc, 120);
+				const allTasks = await listTasks(teamDir, effectiveTlId);
+				const owned = allTasks.filter((t) => t.owner === name);
+				const activeTask = owned.find((t) => t.status === "in_progress");
+				const model = memberCfg?.meta?.["model"];
+				const cwd = memberCfg?.cwd;
+
+				const lines: string[] = [
+					`${formatMemberDisplayName(style, name)}: ${displayStatus}`,
+					`time in state: ${elapsed || "(unknown)"}`,
+					`last event: ${noEventFor || "(unknown)"} ago`,
+					`current activity: ${currentTool || "(none)"}`,
+					`tool calls: ${activity.toolUseCount} · turns: ${activity.turnCount} · tokens: ${formatTokens(activity.totalTokens)}`,
+				];
+				if (typeof model === "string" && model) lines.push(`model: ${model}`);
+				if (cwd) lines.push(`cwd: ${cwd}`);
+				if (activeTask) lines.push(`active task: #${activeTask.id} ${activeTask.subject}`);
+				lines.push(`tasks: ${owned.filter((t) => t.status === "pending").length} pending · ${owned.filter((t) => t.status === "in_progress").length} in-progress · ${owned.filter((t) => t.status === "completed").length} completed`);
+				if (msgPreview) lines.push(`last message: ${msgPreview}`);
+				if (displayStatus === "stalled") {
+					lines.push(`\u26a0 WARNING: no agent events for ${noEventFor} — worker may be stalled`);
+				}
+
+				return {
+					content: [{ type: "text", text: lines.join("\n") }],
+					details: {
+						action,
+						teamId,
+						name,
+						status: displayStatus,
+						transportStatus: rpc?.status ?? "unknown",
+						timeInState: elapsed,
+						lastEventAgo: noEventFor,
+						currentTool: activity.currentToolName,
+						toolUseCount: activity.toolUseCount,
+						turnCount: activity.turnCount,
+						totalTokens: activity.totalTokens,
+						model: typeof model === "string" ? model : undefined,
+						activeTaskId: activeTask?.id,
+						tasks: {
+							pending: owned.filter((t) => t.status === "pending").length,
+							inProgress: owned.filter((t) => t.status === "in_progress").length,
+							completed: owned.filter((t) => t.status === "completed").length,
+						},
+						stalled: displayStatus === "stalled",
+					},
 				};
 			}
 
@@ -626,6 +806,79 @@ export function registerTeamsTool(opts: {
 				};
 			}
 
+			if (action === "team_done") {
+				const tasks = await listTasks(teamDir, effectiveTlId);
+				const inProgress = tasks.filter((t) => t.status === "in_progress");
+				const force = params.all === true;
+
+				if (inProgress.length > 0 && !force) {
+					return {
+						content: [{
+							type: "text",
+							text: `${inProgress.length} task(s) still in progress. Set all=true to force.`,
+						}],
+						details: {
+							action,
+							teamId,
+							status: "blocked",
+							reason: "tasks_in_progress",
+							inProgress: inProgress.length,
+							hint: "Set all=true to force, or wait for tasks to complete.",
+						},
+					};
+				}
+
+				// Stop all RPC teammates (reuses leader's stopAllTeammates for proper
+				// event unsub + tracker/transcript cleanup — avoids stale state on reuse).
+				await stopAllTeammates("team done");
+
+				// Mark config workers offline + send shutdown mailbox messages
+				const cfgWorkers = cfg.members.filter((m) => m.role === "worker" && m.status === "online");
+				for (const m of cfgWorkers) {
+					if (teammates.has(m.name)) continue; // already stopped via RPC above
+					const ts = new Date().toISOString();
+					try {
+						await writeToMailbox(teamDir, TEAM_MAILBOX_NS, m.name, {
+							from: cfg.leadName,
+							text: JSON.stringify({
+								type: "shutdown_request",
+								requestId: randomUUID(),
+								from: cfg.leadName,
+								timestamp: ts,
+								reason: "Team done",
+							}),
+							timestamp: ts,
+						});
+					} catch {
+						// ignore mailbox errors
+					}
+					await setMemberStatus(teamDir, m.name, "offline", {
+						meta: { stoppedReason: "team-done", stoppedAt: ts },
+					});
+				}
+
+				await refreshTasks();
+				hideWidget();
+
+				const completed = tasks.filter((t) => t.status === "completed").length;
+				const pending = tasks.filter((t) => t.status === "pending").length;
+				return {
+					content: [{
+						type: "text",
+						text: `Team done. ${tasks.length} task(s): ${completed} completed, ${pending} pending${inProgress.length > 0 ? `, ${inProgress.length} were in-progress (unassigned)` : ""}. Widget hidden.`,
+					}],
+					details: {
+						action,
+						teamId,
+						status: "succeeded",
+						total: tasks.length,
+						completed,
+						pending,
+						unassigned: inProgress.length,
+					},
+				};
+			}
+
 			if (action === "plan_approve") {
 				const nameRaw = params.name?.trim();
 				const name = sanitizeName(nameRaw ?? "");
@@ -696,6 +949,114 @@ export function registerTeamsTool(opts: {
 				};
 			}
 
+			if (action === "model_policy_get") {
+				const leaderProvider = ctx.model?.provider;
+				const leaderModelId = ctx.model?.id;
+				const leaderModel = formatProviderModel(leaderProvider, leaderModelId);
+				const leaderModelDeprecated = leaderModelId ? isDeprecatedTeammateModelId(leaderModelId) : false;
+				const resolved = resolveTeammateModelSelection({
+					leaderProvider,
+					leaderModelId,
+				});
+				if (!resolved.ok) {
+					return {
+						content: [{ type: "text", text: `Model policy resolution failed: ${resolved.error}` }],
+						details: {
+							action,
+							teamId,
+							error: resolved.error,
+							reason: resolved.reason,
+						},
+					};
+				}
+
+				const effectiveModel = formatProviderModel(resolved.value.provider, resolved.value.modelId);
+				const lines: string[] = [
+					"Model policy",
+					"deprecated model family: claude-sonnet-4* (except claude-sonnet-4-5 / claude-sonnet-4.5)",
+					`leader model: ${leaderModel ?? "(unknown)"}`,
+					`leader model deprecated: ${leaderModelDeprecated ? "yes" : "no"}`,
+					`default teammate selection: source=${describeModelSource(resolved.value.source)}, model=${effectiveModel ?? "(teammate default)"}`,
+					"override forms: '<provider>/<modelId>' or '<modelId>' (inherits leader provider when available)",
+				];
+
+				return {
+					content: [{ type: "text", text: lines.join("\n") }],
+					details: {
+						action,
+						teamId,
+						deprecatedPolicy: {
+							family: "claude-sonnet-4",
+							allowedExceptions: ["claude-sonnet-4-5", "claude-sonnet-4.5"],
+						},
+						leader: {
+							provider: leaderProvider,
+							modelId: leaderModelId,
+							model: leaderModel,
+							deprecated: leaderModelDeprecated,
+						},
+						defaultSelection: {
+							source: resolved.value.source,
+							provider: resolved.value.provider,
+							modelId: resolved.value.modelId,
+							model: effectiveModel,
+							warnings: resolved.value.warnings,
+						},
+					},
+				};
+			}
+
+			if (action === "model_policy_check") {
+				const modelInput = params.model?.trim();
+				const resolved = resolveTeammateModelSelection({
+					modelOverride: modelInput,
+					leaderProvider: ctx.model?.provider,
+					leaderModelId: ctx.model?.id,
+				});
+
+				if (!resolved.ok) {
+					const lines = [
+						"Model policy check: rejected",
+						`input: ${modelInput ?? "(none)"}`,
+						`reason: ${resolved.error}`,
+					];
+					return {
+						content: [{ type: "text", text: lines.join("\n") }],
+						details: {
+							action,
+							teamId,
+							accepted: false,
+							input: modelInput,
+							error: resolved.error,
+							reason: resolved.reason,
+						},
+					};
+				}
+
+				const resolvedModel = formatProviderModel(resolved.value.provider, resolved.value.modelId);
+				const lines = [
+					"Model policy check: accepted",
+					`input: ${modelInput ?? "(none)"}`,
+					`source: ${describeModelSource(resolved.value.source)}`,
+					`resolved model: ${resolvedModel ?? "(teammate default)"}`,
+				];
+				for (const warning of resolved.value.warnings) lines.push(`warning: ${warning}`);
+				return {
+					content: [{ type: "text", text: lines.join("\n") }],
+					details: {
+						action,
+						teamId,
+						accepted: true,
+						input: modelInput,
+						source: resolved.value.source,
+						provider: resolved.value.provider,
+						modelId: resolved.value.modelId,
+						model: resolvedModel,
+						warnings: resolved.value.warnings,
+					},
+				};
+			}
+
 			if (action === "hooks_policy_get") {
 				const configuredFailureAction: TeamsHookFailureAction | undefined = cfg.hooks?.failureAction;
 				const configuredFollowupOwner: TeamsHookFollowupOwnerPolicy | undefined = cfg.hooks?.followupOwner;
@@ -869,6 +1230,9 @@ export function registerTeamsTool(opts: {
 				warnings.push(...res.warnings);
 			}
 
+			// Two-pass delegation: create all tasks first, then notify workers.
+			// This ensures DelegationTracker has the batch registered before any
+			// worker can complete a task and emit an idle_notification.
 			const assignments: Array<{ taskId: string; assignee: string; subject: string }> = [];
 			let rr = 0;
 			for (const t of inputTasks) {
@@ -909,13 +1273,23 @@ export function registerTeamsTool(opts: {
 				const subject = firstLine.slice(0, 120);
 				const task = await createTask(teamDir, effectiveTlId, { subject, description, owner: assignee });
 
-				await writeToMailbox(teamDir, effectiveTlId, assignee, {
+				assignments.push({ taskId: task.id, assignee, subject });
+			}
+
+			// Register batch BEFORE notifying workers so completions are never missed.
+			if (delegationTracker && assignments.length > 0) {
+				delegationTracker.addBatch(assignments.map((a) => a.taskId));
+			}
+
+			// Now notify workers via mailbox.
+			for (const a of assignments) {
+				const task = await getTask(teamDir, effectiveTlId, a.taskId);
+				if (!task) continue;
+				await writeToMailbox(teamDir, effectiveTlId, a.assignee, {
 					from: cfg.leadName,
 					text: JSON.stringify(taskAssignmentPayload(task, cfg.leadName)),
 					timestamp: new Date().toISOString(),
 				});
-
-				assignments.push({ taskId: task.id, assignee, subject });
 			}
 
 			void refreshTasks().finally(renderWidget);
@@ -923,6 +1297,8 @@ export function registerTeamsTool(opts: {
 			const lines: string[] = [];
 			if (spawned.length) {
 				lines.push(`Spawned: ${spawned.map((n) => formatMemberDisplayName(style, n)).join(", ")}`);
+				if (spawnModel) lines.push(`model: ${spawnModel}`);
+				if (spawnThinking) lines.push(`thinking: ${spawnThinking}`);
 			}
 			lines.push(`Delegated ${assignments.length} task(s):`);
 			for (const a of assignments) {