indus-swarms 0.1.0

package/extensions/teams/leader-lifecycle-commands.ts

@@ -0,0 +1,559 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionCommandContext, ExtensionContext } from "indusagi-coding-agent";
+import { cleanupTeamDir } from "./cleanup.js";
+import { writeToMailbox } from "./mailbox.js";
+import { sanitizeName } from "./names.js";
+import { getTeamDir, getTeamsRootDir, getTeamsStylesDir } from "./paths.js";
+import { TEAM_MAILBOX_NS } from "./protocol.js";
+import { unassignTasksForAgent, type TeamTask } from "./task-store.js";
+import { setMemberStatus, setTeamStyle, type TeamConfig } from "./team-config.js";
+import {
+	type TeamsStyle,
+	formatMemberDisplayName,
+	getTeamsStrings,
+	listAvailableTeamsStyles,
+	normalizeTeamsStyleId,
+	resolveTeamsStyleDefinition,
+	formatTeamsTemplate,
+} from "./teams-style.js";
+import type { TeammateRpc } from "./teammate-rpc.js";
+
+export async function handleTeamDelegateCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	getDelegateMode: () => boolean;
+	setDelegateMode: (next: boolean) => void;
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, rest, getDelegateMode, setDelegateMode, renderWidget } = opts;
+	const arg = rest[0];
+	if (arg === "on") setDelegateMode(true);
+	else if (arg === "off") setDelegateMode(false);
+	else setDelegateMode(!getDelegateMode());
+	ctx.ui.notify(`Delegate mode ${getDelegateMode() ? "ON" : "OFF"}`, "info");
+	renderWidget();
+}
+
+export async function handleTeamStyleCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamDir: string;
+	getStyle: () => TeamsStyle;
+	setStyle: (next: TeamsStyle) => void;
+	refreshTasks: () => Promise<void>;
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, rest, teamDir, getStyle, setStyle, refreshTasks, renderWidget } = opts;
+	const argRaw = rest[0];
+	if (!argRaw) {
+		ctx.ui.notify(
+			"Teams style:\n" +
+				`  current: ${getStyle()}\n` +
+				"  list:   /team style list\n" +
+				"  set:    /team style <name>\n" +
+				"  init:   /team style init <name> [extends <base>]",
+			"info",
+		);
+		return;
+	}
+
+	if (argRaw === "list") {
+		const { dir, all, builtins, customs } = listAvailableTeamsStyles();
+		ctx.ui.notify(
+			[
+				"Available team styles:",
+				"",
+				`built-in: ${builtins.join(", ")}`,
+				customs.length ? `custom:   ${customs.join(", ")}` : "custom:   (none)",
+				"",
+				"To add a custom style, create a JSON file:",
+				`  ${dir}/<style>.json`,
+				"",
+				`All: ${all.join(", ")}`,
+			].join("\n"),
+			"info",
+		);
+		return;
+	}
+
+	if (argRaw === "init") {
+		const nameRaw = rest[1];
+		const styleId = normalizeTeamsStyleId(nameRaw);
+		if (!styleId) {
+			ctx.ui.notify("Usage: /team style init <name> [extends <base>]", "error");
+			return;
+		}
+
+		let extendsRaw: string | undefined;
+		if (rest[2] === "extends") extendsRaw = rest[3];
+		else extendsRaw = rest[2];
+		const extendsId = normalizeTeamsStyleId(extendsRaw) ?? "normal";
+
+		try {
+			resolveTeamsStyleDefinition(extendsId, { strict: true });
+		} catch (err) {
+			ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
+			return;
+		}
+
+		const dir = getTeamsStylesDir();
+		const file = path.join(dir, `${styleId}.json`);
+		try {
+			await fs.promises.mkdir(dir, { recursive: true });
+			const base = resolveTeamsStyleDefinition(extendsId);
+			const template = {
+				extends: extendsId,
+				strings: base.strings,
+				naming: base.naming,
+			};
+			await fs.promises.writeFile(file, JSON.stringify(template, null, 2) + "\n", { encoding: "utf8", flag: "wx" });
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			ctx.ui.notify(`Failed to create style file: ${file}\n${msg}`, "error");
+			return;
+		}
+
+		ctx.ui.notify(
+			[
+				"Created style template:",
+				`  ${file}`,
+				"",
+				"Edit it, then activate with:",
+				`  /team style ${styleId}`,
+			].join("\n"),
+			"info",
+		);
+		return;
+	}
+
+	const next = normalizeTeamsStyleId(argRaw);
+	if (!next) {
+		ctx.ui.notify("Usage: /team style <name> | /team style list | /team style init <name>", "error");
+		return;
+	}
+
+	try {
+		// Validate that the style exists (built-in or custom file). Falls back to throwing with a useful message.
+		resolveTeamsStyleDefinition(next, { strict: true });
+	} catch (err) {
+		ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
+		return;
+	}
+
+	setStyle(next);
+	await setTeamStyle(teamDir, next);
+	await refreshTasks();
+	renderWidget();
+	ctx.ui.notify(`Teams style set to ${next}`, "info");
+}
+
+export async function handleTeamCleanupCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	teammates: Map<string, TeammateRpc>;
+	refreshTasks: () => Promise<void>;
+	getTasks: () => TeamTask[];
+	renderWidget: () => void;
+	style: TeamsStyle;
+}): Promise<void> {
+	const { ctx, rest, teamId, teammates, refreshTasks, getTasks, renderWidget, style } = opts;
+	const strings = getTeamsStrings(style);
+
+	const flags = rest.filter((a) => a.startsWith("--"));
+	const argsOnly = rest.filter((a) => !a.startsWith("--"));
+	const force = flags.includes("--force");
+
+	const unknownFlags = flags.filter((f) => f !== "--force");
+	if (unknownFlags.length) {
+		ctx.ui.notify(`Unknown flag(s): ${unknownFlags.join(", ")}`, "error");
+		return;
+	}
+	if (argsOnly.length) {
+		ctx.ui.notify("Usage: /team cleanup [--force]", "error");
+		return;
+	}
+
+	const teamsRoot = getTeamsRootDir();
+	const teamDir = getTeamDir(teamId);
+
+	if (!force && teammates.size > 0) {
+		ctx.ui.notify(
+			`Refusing to cleanup while ${teammates.size} RPC ${strings.memberTitle.toLowerCase()}(s) are running. Stop them first or use --force.`,
+			"error",
+		);
+		return;
+	}
+
+	await refreshTasks();
+	const tasks = getTasks();
+	const inProgress = tasks.filter((t) => t.status === "in_progress");
+	if (!force && inProgress.length > 0) {
+		ctx.ui.notify(
+			`Refusing to cleanup with ${inProgress.length} in_progress task(s). Complete/unassign them first or use --force.`,
+			"error",
+		);
+		return;
+	}
+
+	if (!force) {
+		// Only prompt in interactive TTY mode. In RPC mode, confirm() would require
+		// the host to send extension_ui_response messages.
+		if (process.stdout.isTTY && process.stdin.isTTY) {
+			const ok = await ctx.ui.confirm(
+				"Cleanup team",
+				[
+					"Delete ALL team artifacts for this session?",
+					"",
+					`teamId: ${teamId}`,
+					`teamDir: ${teamDir}`,
+					`tasks: ${tasks.length} (in_progress: ${inProgress.length})`,
+				].join("\n"),
+			);
+			if (!ok) return;
+		} else {
+			ctx.ui.notify("Refusing to cleanup in non-interactive mode without --force", "error");
+			return;
+		}
+	}
+
+	try {
+		await cleanupTeamDir(teamsRoot, teamDir);
+	} catch (err) {
+		ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
+		return;
+	}
+
+	ctx.ui.notify(`Cleaned up team directory: ${teamDir}`, "warning");
+	await refreshTasks();
+	renderWidget();
+}
+
+export async function handleTeamShutdownCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	teammates: Map<string, TeammateRpc>;
+	getTeamConfig: () => TeamConfig | null;
+	leadName: string;
+	style: TeamsStyle;
+	getCurrentCtx: () => ExtensionContext | null;
+	getActiveTeamId: () => string;
+	stopAllTeammates: (ctx: ExtensionContext, reason: string) => Promise<void>;
+	refreshTasks: () => Promise<void>;
+	getTasks: () => TeamTask[];
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, rest, teamId, teammates, getTeamConfig, leadName, style, getCurrentCtx, getActiveTeamId, stopAllTeammates, refreshTasks, getTasks, renderWidget } = opts;
+	const strings = getTeamsStrings(style);
+	const nameRaw = rest[0];
+
+	// /team shutdown <name> [reason...] = request graceful worker shutdown via mailbox
+	if (nameRaw) {
+		const name = sanitizeName(nameRaw);
+		const reason = rest.slice(1).join(" ").trim() || undefined;
+
+		const teamDir = getTeamDir(teamId);
+
+		const requestId = randomUUID();
+		const ts = new Date().toISOString();
+		const payload: {
+			type: "shutdown_request";
+			requestId: string;
+			from: string;
+			timestamp: string;
+			reason?: string;
+		} = {
+			type: "shutdown_request",
+			requestId,
+			from: leadName,
+			timestamp: ts,
+			...(reason ? { reason } : {}),
+		};
+
+		await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
+			from: leadName,
+			text: JSON.stringify(payload),
+			timestamp: ts,
+		});
+
+		// Best-effort: record in member metadata (if present).
+		void setMemberStatus(teamDir, name, "online", {
+			meta: {
+				shutdownRequestedAt: ts,
+				shutdownRequestId: requestId,
+				...(reason ? { shutdownReason: reason } : {}),
+			},
+		});
+
+		ctx.ui.notify(`${formatMemberDisplayName(style, name)} ${strings.shutdownRequestedVerb}`, "info");
+
+		// Optional fallback for RPC teammates: force stop if it doesn't exit.
+		const t = teammates.get(name);
+		if (t) {
+			setTimeout(() => {
+				if (getActiveTeamId() !== teamId) return;
+				if (t.status === "stopped" || t.status === "error") return;
+				void (async () => {
+					try {
+						await t.stop();
+						await setMemberStatus(teamDir, name, "offline", {
+							meta: { shutdownFallback: true, shutdownRequestId: requestId },
+						});
+						getCurrentCtx()?.ui.notify(
+							`${formatMemberDisplayName(style, name)} did not comply; ${strings.killedVerb}`,
+							"warning",
+						);
+					} catch {
+						// ignore
+					}
+				})();
+			}, 10_000);
+		}
+
+		return;
+	}
+
+	// /team shutdown (no args) = stop all teammates but keep the leader session alive
+	await refreshTasks();
+	const cfgBefore = getTeamConfig();
+	const cfgWorkersOnline = (cfgBefore?.members ?? []).filter((m) => m.role === "worker" && m.status === "online");
+
+	const activeNames = new Set<string>();
+	for (const name of teammates.keys()) activeNames.add(name);
+	for (const m of cfgWorkersOnline) activeNames.add(m.name);
+
+	if (activeNames.size === 0) {
+		const members = `${strings.memberTitle.toLowerCase()}s`;
+		ctx.ui.notify(formatTeamsTemplate(strings.noMembersToShutdown, { members, count: "0" }), "info");
+		return;
+	}
+
+	if (process.stdout.isTTY && process.stdin.isTTY) {
+		const plural = activeNames.size === 1 ? "" : "s";
+		const members = `${strings.memberTitle.toLowerCase()}${plural}`;
+		const msg = formatTeamsTemplate(strings.shutdownAllPrompt, {
+			count: String(activeNames.size),
+			members,
+		});
+		const ok = await ctx.ui.confirm("Shutdown team", msg);
+		if (!ok) return;
+	}
+
+	const reason = "Stopped by /team shutdown";
+	// Stop RPC teammates we own
+	await stopAllTeammates(ctx, reason);
+
+	// Best-effort: ask *manual* workers (persisted in config.json) to shut down too.
+	// Also mark them offline so they stop cluttering the UI if they were left behind from old runs.
+	await refreshTasks();
+	const cfg = getTeamConfig();
+	const teamDir = getTeamDir(teamId);
+
+	const inProgressOwners = new Set<string>();
+	for (const t of getTasks()) {
+		if (t.owner && t.status === "in_progress") inProgressOwners.add(t.owner);
+	}
+
+	const manualWorkers = (cfg?.members ?? []).filter((m) => m.role === "worker" && m.status === "online");
+	for (const m of manualWorkers) {
+		// If it's an RPC teammate we already stopped above, skip mailbox request.
+		if (teammates.has(m.name)) continue;
+		// If a manual worker still owns an in-progress task, don't force it offline in the UI.
+		if (inProgressOwners.has(m.name)) continue;
+
+		const requestId = randomUUID();
+		const ts = new Date().toISOString();
+		try {
+			await writeToMailbox(teamDir, TEAM_MAILBOX_NS, m.name, {
+				from: leadName,
+				text: JSON.stringify({
+					type: "shutdown_request",
+					requestId,
+					from: leadName,
+					timestamp: ts,
+					reason,
+				}),
+				timestamp: ts,
+			});
+		} catch {
+			// ignore mailbox errors
+		}
+
+		void setMemberStatus(teamDir, m.name, "offline", {
+			meta: { shutdownRequestedAt: ts, shutdownRequestId: requestId, stoppedReason: reason },
+		});
+	}
+
+	renderWidget();
+	const members = `${strings.memberTitle.toLowerCase()}s`;
+	ctx.ui.notify(formatTeamsTemplate(strings.teamEndedAllStopped, { members, count: String(activeNames.size) }), "info");
+}
+
+export async function handleTeamPruneCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	teammates: Map<string, TeammateRpc>;
+	getTeamConfig: () => TeamConfig | null;
+	refreshTasks: () => Promise<void>;
+	getTasks: () => TeamTask[];
+	style: TeamsStyle;
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, rest, teamId, teammates, getTeamConfig, refreshTasks, getTasks, style, renderWidget } = opts;
+	const strings = getTeamsStrings(style);
+
+	const flags = rest.filter((a) => a.startsWith("--"));
+	const argsOnly = rest.filter((a) => !a.startsWith("--"));
+	const all = flags.includes("--all");
+	const unknownFlags = flags.filter((f) => f !== "--all");
+	if (unknownFlags.length) {
+		ctx.ui.notify(`Unknown flag(s): ${unknownFlags.join(", ")}`, "error");
+		return;
+	}
+	if (argsOnly.length) {
+		ctx.ui.notify("Usage: /team prune [--all]", "error");
+		return;
+	}
+
+	await refreshTasks();
+	const cfg = getTeamConfig();
+	const members = (cfg?.members ?? []).filter((m) => m.role === "worker");
+	if (!members.length) {
+		ctx.ui.notify(`No ${strings.memberTitle.toLowerCase()}s to prune`, "info");
+		renderWidget();
+		return;
+	}
+
+	const inProgressOwners = new Set<string>();
+	for (const t of getTasks()) {
+		if (t.owner && t.status === "in_progress") inProgressOwners.add(t.owner);
+	}
+
+	const cutoffMs = 60 * 60 * 1000; // 1h
+	const now = Date.now();
+
+	const pruned: string[] = [];
+	for (const m of members) {
+		if (teammates.has(m.name)) continue; // still tracked as RPC
+		if (inProgressOwners.has(m.name)) continue; // still actively working
+		if (!all) {
+			const lastSeen = m.lastSeenAt ? Date.parse(m.lastSeenAt) : NaN;
+			if (!Number.isFinite(lastSeen)) continue;
+			if (now - lastSeen < cutoffMs) continue;
+		}
+
+		const teamDir = getTeamDir(teamId);
+		await setMemberStatus(teamDir, m.name, "offline", {
+			meta: { prunedAt: new Date().toISOString(), prunedBy: "leader" },
+		});
+		pruned.push(m.name);
+	}
+
+	await refreshTasks();
+	renderWidget();
+	ctx.ui.notify(
+		pruned.length
+			? `Pruned ${pruned.length} stale ${strings.memberTitle.toLowerCase()}(s): ${pruned.join(", ")}`
+			: `No stale ${strings.memberTitle.toLowerCase()}s to prune (use --all to force)`,
+		"info",
+	);
+}
+
+export async function handleTeamStopCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	teammates: Map<string, TeammateRpc>;
+	leadName: string;
+	style: TeamsStyle;
+	refreshTasks: () => Promise<void>;
+	getTasks: () => TeamTask[];
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, rest, teamId, teammates, leadName, style, refreshTasks, getTasks, renderWidget } = opts;
+
+	const nameRaw = rest[0];
+	const reason = rest.slice(1).join(" ").trim();
+	if (!nameRaw) {
+		ctx.ui.notify("Usage: /team stop <name> [reason...]", "error");
+		return;
+	}
+	const name = sanitizeName(nameRaw);
+
+	const teamDir = getTeamDir(teamId);
+
+	// Best-effort: include current in-progress task id (if any).
+	await refreshTasks();
+	const tasks = getTasks();
+	const active = tasks.find((x) => x.owner === name && x.status === "in_progress");
+	const taskId = active?.id;
+
+	const ts = new Date().toISOString();
+	await writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
+		from: leadName,
+		text: JSON.stringify({
+			type: "abort_request",
+			requestId: randomUUID(),
+			from: leadName,
+			taskId,
+			reason: reason || undefined,
+			timestamp: ts,
+		}),
+		timestamp: ts,
+	});
+
+	const t = teammates.get(name);
+	if (t) {
+		// Fast-path for RPC teammates.
+		await t.abort();
+	}
+
+	let msg = `${formatMemberDisplayName(style, name)} ${getTeamsStrings(style).abortRequestedVerb}`;
+	if (taskId) msg += ` (task #${taskId})`;
+	if (!t) msg += " (mailbox only)";
+	ctx.ui.notify(msg, "warning");
+	renderWidget();
+}
+
+export async function handleTeamKillCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	teammates: Map<string, TeammateRpc>;
+	leadName: string;
+	style: TeamsStyle;
+	taskListId: string | null;
+	refreshTasks: () => Promise<void>;
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, rest, teamId, teammates, taskListId, leadName: _leadName, style, refreshTasks, renderWidget } = opts;
+	const strings = getTeamsStrings(style);
+
+	const nameRaw = rest[0];
+	if (!nameRaw) {
+		ctx.ui.notify("Usage: /team kill <name>", "error");
+		return;
+	}
+	const name = sanitizeName(nameRaw);
+	const t = teammates.get(name);
+	if (!t) {
+		ctx.ui.notify(`Unknown ${strings.memberTitle.toLowerCase()}: ${name}`, "error");
+		return;
+	}
+
+	await t.stop();
+	teammates.delete(name);
+
+	const teamDir = getTeamDir(teamId);
+	const effectiveTlId = taskListId ?? teamId;
+	await unassignTasksForAgent(teamDir, effectiveTlId, name, `${formatMemberDisplayName(style, name)} ${strings.killedVerb}`);
+	await setMemberStatus(teamDir, name, "offline", { meta: { killedAt: new Date().toISOString() } });
+
+	ctx.ui.notify(`${formatMemberDisplayName(style, name)} ${strings.killedVerb} (SIGTERM)`, "warning");
+	await refreshTasks();
+	renderWidget();
+}

package/extensions/teams/leader-messaging-commands.ts

@@ -0,0 +1,148 @@
+import type { ExtensionCommandContext } from "indusagi-coding-agent";
+import { writeToMailbox } from "./mailbox.js";
+import { sanitizeName } from "./names.js";
+import { getTeamDir } from "./paths.js";
+import { TEAM_MAILBOX_NS } from "./protocol.js";
+import { ensureTeamConfig } from "./team-config.js";
+import type { TeamTask } from "./task-store.js";
+import type { TeammateRpc } from "./teammate-rpc.js";
+import type { TeamsStyle } from "./teams-style.js";
+import { formatMemberDisplayName, getTeamsStrings } from "./teams-style.js";
+
+export async function handleTeamSendCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teammates: Map<string, TeammateRpc>;
+	style: TeamsStyle;
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, rest, teammates, style, renderWidget } = opts;
+	const strings = getTeamsStrings(style);
+
+	const nameRaw = rest[0];
+	const msg = rest.slice(1).join(" ").trim();
+	if (!nameRaw || !msg) {
+		ctx.ui.notify("Usage: /team send <name> <msg...>", "error");
+		return;
+	}
+	const name = sanitizeName(nameRaw);
+	const t = teammates.get(name);
+	if (!t) {
+		ctx.ui.notify(`Unknown ${strings.memberTitle.toLowerCase()}: ${name}`, "error");
+		return;
+	}
+	if (t.status === "streaming") await t.followUp(msg);
+	else await t.prompt(msg);
+	ctx.ui.notify(`Sent to ${name}`, "info");
+	renderWidget();
+}
+
+export async function handleTeamSteerCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teammates: Map<string, TeammateRpc>;
+	style: TeamsStyle;
+	renderWidget: () => void;
+}): Promise<void> {
+	const { ctx, rest, teammates, style, renderWidget } = opts;
+	const strings = getTeamsStrings(style);
+
+	const nameRaw = rest[0];
+	const msg = rest.slice(1).join(" ").trim();
+	if (!nameRaw || !msg) {
+		ctx.ui.notify("Usage: /team steer <name> <msg...>", "error");
+		return;
+	}
+	const name = sanitizeName(nameRaw);
+	const t = teammates.get(name);
+	if (!t) {
+		ctx.ui.notify(`Unknown ${strings.memberTitle.toLowerCase()}: ${name}`, "error");
+		return;
+	}
+	await t.steer(msg);
+	ctx.ui.notify(`Steering sent to ${name}`, "info");
+	renderWidget();
+}
+
+export async function handleTeamDmCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	leadName: string;
+	style: TeamsStyle;
+}): Promise<void> {
+	const { ctx, rest, teamId, leadName, style } = opts;
+
+	const nameRaw = rest[0];
+	const msg = rest.slice(1).join(" ").trim();
+	if (!nameRaw || !msg) {
+		ctx.ui.notify("Usage: /team dm <name> <msg...>", "error");
+		return;
+	}
+	const name = sanitizeName(nameRaw);
+	await writeToMailbox(getTeamDir(teamId), TEAM_MAILBOX_NS, name, {
+		from: leadName,
+		text: msg,
+		timestamp: new Date().toISOString(),
+	});
+	ctx.ui.notify(`DM queued for ${formatMemberDisplayName(style, name)}`, "info");
+}
+
+export async function handleTeamBroadcastCommand(opts: {
+	ctx: ExtensionCommandContext;
+	rest: string[];
+	teamId: string;
+	teammates: Map<string, TeammateRpc>;
+	leadName: string;
+	style: TeamsStyle;
+	refreshTasks: () => Promise<void>;
+	getTasks: () => TeamTask[];
+	getTaskListId: () => string | null;
+}): Promise<void> {
+	const { ctx, rest, teamId, teammates, leadName, style, refreshTasks, getTasks, getTaskListId } = opts;
+	const strings = getTeamsStrings(style);
+
+	const msg = rest.join(" ").trim();
+	if (!msg) {
+		ctx.ui.notify("Usage: /team broadcast <msg...>", "error");
+		return;
+	}
+
+	const teamDir = getTeamDir(teamId);
+	const taskListId = getTaskListId();
+	const cfg = await ensureTeamConfig(teamDir, { teamId, taskListId: taskListId ?? teamId, leadName, style });
+
+	const recipients = new Set<string>();
+	for (const m of cfg.members) {
+		if (m.role === "worker") recipients.add(m.name);
+	}
+	for (const name of teammates.keys()) recipients.add(name);
+
+	// Include task owners (helps reach manual tmux workers not tracked as RPC teammates).
+	await refreshTasks();
+	for (const t of getTasks()) {
+		if (t.owner && t.owner !== leadName) recipients.add(t.owner);
+	}
+
+	const names = Array.from(recipients).sort();
+	if (names.length === 0) {
+		ctx.ui.notify(`No ${strings.memberTitle.toLowerCase()}s to broadcast to`, "warning");
+		return;
+	}
+
+	const ts = new Date().toISOString();
+	await Promise.all(
+		names.map((name) =>
+			writeToMailbox(teamDir, TEAM_MAILBOX_NS, name, {
+				from: leadName,
+				text: msg,
+				timestamp: ts,
+			}),
+		),
+	);
+
+	ctx.ui.notify(
+		`Broadcast queued for ${names.length} ${strings.memberTitle.toLowerCase()}(s): ${names.map((n) => formatMemberDisplayName(style, n)).join(", ")}`,
+		"info",
+	);
+}