diff --git a/packages/coding-agent/CHANGELOG.md b/packages/coding-agent/CHANGELOG.md
index e4a78d177..f44cda3a7 100644
--- a/packages/coding-agent/CHANGELOG.md
+++ b/packages/coding-agent/CHANGELOG.md
@@ -122,6 +122,7 @@
 - Added an optional `role` field to `task` spawns that gives each subagent a tailored specialist identity: the role is injected as a system-prompt specialization preamble and becomes the subagent's display name and telemetry identity in the registry, IRC roster, and Agent Hub, so delegated trees are no longer clones of one generic worker ([#2467](https://github.com/can1357/oh-my-pi/issues/2467))
 - Added a non-blocking specialization advisory to the `task` tool: when a spawner with remaining depth capacity spawns generic role-less workers (a `task`/`quick_task` spawn without a `role`, or the same agent cloned ≥2× all without roles), the result steers it toward tailored specialists. Gated so a leaf at max recursion depth is never nudged; the task-tool depth gate is extracted into a shared `canSpawnAtDepth` helper ([#2469](https://github.com/can1357/oh-my-pi/issues/2469))
 - Added a work-aware IRC roster: `irc list` and the subagent peer roster now show each peer's current activity (a short gist of its latest intent/tool) alongside its role-derived display name, so a tree of tailored specialists is legible enough to coordinate. Backed by a new display-only `activity` field on the agent registry ([#2470](https://github.com/can1357/oh-my-pi/issues/2470))
+- Added proactive IRC coordination: when one `task` call spawns ≥2 live siblings with spawn capacity remaining, the result suggests coordinating overlapping work via `irc` (composed onto the specialization advisory), and the subagent COOP/`irc` prompts now actively steer discovery (`list`), coordination (message before overlapping edits), and follow-up (`replyTo`/`await`) instead of only assuming agents resolve collisions on their own ([#2471](https://github.com/can1357/oh-my-pi/issues/2471))
 
 ### Changed
 
diff --git a/packages/coding-agent/src/prompts/system/subagent-system-prompt.md b/packages/coding-agent/src/prompts/system/subagent-system-prompt.md
index 59337b45c..f38f2cf45 100644
--- a/packages/coding-agent/src/prompts/system/subagent-system-prompt.md
+++ b/packages/coding-agent/src/prompts/system/subagent-system-prompt.md
@@ -41,7 +41,10 @@ You NEVER modify files outside this tree or in the original repository.
 You can reach other live agents via the `irc` tool. Your id is `{{ircSelfId}}`. Currently visible peers:
 {{ircPeers}}
 
-Use `irc` only when you need a quick answer from a peer; NEVER use it for long-form content. Address peers by id or use `"all"` to broadcast.
+Use `irc` only for quick coordination, never long-form content. Address peers by id or use `"all"` to broadcast.
+- Discovery: the roster above shows each peer's role and what it is doing now; `irc` op:"list" refreshes it.
+- Coordination: before you edit a file or start work a sibling may already own, message that peer first — overlapping edits collide.
+- Follow-up: answer a peer's question with a short reply (set `replyTo`); use `await` only when you genuinely cannot proceed without the answer.
 {{/if}}
 
 COMPLETION
diff --git a/packages/coding-agent/src/prompts/tools/irc.md b/packages/coding-agent/src/prompts/tools/irc.md
index b202daed9..74f819846 100644
--- a/packages/coding-agent/src/prompts/tools/irc.md
+++ b/packages/coding-agent/src/prompts/tools/irc.md
@@ -17,7 +17,7 @@ Reach for `irc` proactively when continuing alone is wasteful or wrong; when in
 - **Unexpected state** — missing file, config contradicting the assignment, API/tool behaving differently than told. DM `Main` (or your spawner) instead of guessing.
 - **Blocked by another agent** — a peer holds the file/branch/resource or decision you need, or started the change you're about to make. DM them (or broadcast to discover who) before duplicating work.
 - **Decision outside your scope** — a genuine fork the assignment didn't pre-decide. Ask the requester rather than picking unilaterally.
-- **Coordination** — a peer's in-flight work would benefit from yours, or vice-versa.
+- **Coordination** — a peer's in-flight work overlaps yours (the roster shows each peer's role and current activity); message before editing a shared file or duplicating a sibling's change.
 
 NEVER for: routine progress updates, things a tool call can verify, questions your assignment/repo/docs already answer.
 </when_to_use>
diff --git a/packages/coding-agent/src/task/index.ts b/packages/coding-agent/src/task/index.ts
index a846f69fb..e9ad724a7 100644
--- a/packages/coding-agent/src/task/index.ts
+++ b/packages/coding-agent/src/task/index.ts
@@ -366,6 +366,49 @@ export function buildSpecializationAdvisory(
 	);
 }
 
+/**
+ * Suggestion — never a rejection — nudging the spawner to coordinate via `irc`
+ * when one call creates ≥2 live siblings and it still holds spawn capacity.
+ * Returns undefined when there is nothing to coordinate or IRC is unavailable.
+ */
+export function buildCoordinationAdvisory(
+	items: TaskItem[],
+	depthCapacity: boolean,
+	ircEnabled: boolean,
+): string | undefined {
+	if (!depthCapacity || !ircEnabled || items.length < 2) return undefined;
+	return (
+		`Coordinate: ${items.length} siblings are running together. If their work overlaps, have them ` +
+		`message each other via \`irc\` (by id, or "all" to broadcast) before editing shared files — ` +
+		`live coordination beats a serial handoff. Check \`irc\` op:"list" to see who is doing what.`
+	);
+}
+
+/**
+ * Compose the non-blocking advisory appended to a `task` result: the
+ * specialization nudge, plus — only when the siblings keep running after this
+ * call (`willRunAsync`) — the coordination suggestion. Coordination is gated on
+ * async because a sync fanout's siblings have already finished, so a
+ * "coordinate while they run" hint would misfire. Returns undefined when
+ * neither applies.
+ */
+export function composeSpawnAdvisory(args: {
+	agentName: string | undefined;
+	items: TaskItem[];
+	depthCapacity: boolean;
+	ircEnabled: boolean;
+	willRunAsync: boolean;
+}): string | undefined {
+	return (
+		[
+			buildSpecializationAdvisory(args.agentName, args.items, args.depthCapacity),
+			args.willRunAsync ? buildCoordinationAdvisory(args.items, args.depthCapacity, args.ircEnabled) : undefined,
+		]
+			.filter(Boolean)
+			.join("\n\n") || undefined
+	);
+}
+
 /** Sentinel for async jobs whose subagent finished with a failing result; progress is already updated. */
 class TaskJobError extends Error {}
 
@@ -539,16 +582,35 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			this.session.settings.get("task.maxRecursionDepth") ?? 2,
 			this.session.taskDepth ?? 0,
 		);
-		const advisory = buildSpecializationAdvisory(params.agent, spawnItems, depthCapacity);
+		const ircEnabled = isIrcEnabled(this.session.settings, this.session.taskDepth ?? 0);
+		// Coordination only makes sense when the siblings keep running after this
+		// call returns (async). In the sync fallback they have already completed,
+		// so a "coordinate while they run" hint would misfire.
+		const willRunAsync = !!manager && selectedAgent?.blocking !== true;
+		const advisory = this.session.suppressSpawnAdvisory
+			? undefined
+			: composeSpawnAdvisory({
+					agentName: params.agent,
+					items: spawnItems,
+					depthCapacity,
+					ircEnabled,
+					willRunAsync,
+				});
+		// Returns a fresh result (copied content array, copied text part) rather
+		// than mutating the caller's — task results are short-lived here, but an
+		// in-place edit on a shared/cached AgentToolResult would be a hidden trap.
 		const withAdvisory = (result: AgentToolResult<TaskToolDetails>): AgentToolResult<TaskToolDetails> => {
 			if (!advisory) return result;
-			const textPart = result.content.find(part => part.type === "text");
-			if (textPart && typeof textPart.text === "string") {
-				textPart.text = `${textPart.text}\n\n${advisory}`;
-			} else {
-				result.content.push({ type: "text", text: advisory });
-			}
-			return result;
+			let appended = false;
+			const content = result.content.map(part => {
+				if (!appended && part.type === "text" && typeof part.text === "string") {
+					appended = true;
+					return { ...part, text: `${part.text}\n\n${advisory}` };
+				}
+				return part;
+			});
+			if (!appended) content.push({ type: "text", text: advisory });
+			return { ...result, content };
 		};
 		if (!asyncEnabled || !manager || selectedAgent?.blocking === true) {
 			// Sync fallback: async execution disabled, orphaned host that never
@@ -614,7 +676,6 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			},
 		});
 
-		const ircEnabled = isIrcEnabled(this.session.settings, this.session.taskDepth ?? 0);
 		const started: Array<{ agentId: string; jobId: string; description?: string }> = [];
 		const failedSchedules: string[] = [];
 		for (const spawn of spawns) {
diff --git a/packages/coding-agent/test/task/coordination-advisory.test.ts b/packages/coding-agent/test/task/coordination-advisory.test.ts
new file mode 100644
index 000000000..21934552f
--- /dev/null
+++ b/packages/coding-agent/test/task/coordination-advisory.test.ts
@@ -0,0 +1,111 @@
+import { describe, expect, it } from "bun:test";
+import { buildCoordinationAdvisory, composeSpawnAdvisory } from "@oh-my-pi/pi-coding-agent/task";
+import type { TaskItem } from "@oh-my-pi/pi-coding-agent/task/types";
+import { prompt } from "@oh-my-pi/pi-utils";
+import subagentSystemPromptTemplate from "../../src/prompts/system/subagent-system-prompt.md" with { type: "text" };
+
+// Contract: a multi-sibling spawn with spawn capacity and IRC available draws
+// a proactive coordinate-via-irc suggestion, and the subagent COOP prompt
+// actively tells peers to coordinate before overlapping edits.
+
+const item = (): TaskItem => ({ assignment: "do the thing" });
+
+describe("buildCoordinationAdvisory", () => {
+	it("suggests irc coordination for >=2 siblings with capacity and irc enabled", () => {
+		const advice = buildCoordinationAdvisory([item(), item()], true, true);
+		expect(advice).toBeDefined();
+		expect(advice).toContain("`irc`");
+	});
+
+	it("stays silent for a single spawn", () => {
+		expect(buildCoordinationAdvisory([item()], true, true)).toBeUndefined();
+	});
+
+	it("stays silent when irc is unavailable", () => {
+		expect(buildCoordinationAdvisory([item(), item()], true, false)).toBeUndefined();
+	});
+
+	it("stays silent at max depth (no spawn capacity)", () => {
+		expect(buildCoordinationAdvisory([item(), item()], false, true)).toBeUndefined();
+	});
+});
+
+describe("subagent COOP irc guidance", () => {
+	it("prompts coordination before overlapping edits when peers are present", () => {
+		const out = prompt.render(subagentSystemPromptTemplate, {
+			agent: "Base worker.",
+			ircPeers: "- `Sib` — task (sub, running)",
+			ircSelfId: "Self",
+		});
+		expect(out).toContain("before you edit");
+		expect(out).toMatch(/overlapping edits collide/i);
+	});
+});
+
+// Contract: TaskTool.execute composes the specialization nudge with the
+// coordination suggestion, gating the latter to the async path (sync siblings
+// have already finished). composeSpawnAdvisory is the seam that decision flows
+// through, so the gating is pinned here rather than only inside the builders.
+describe("composeSpawnAdvisory", () => {
+	const worker = (role?: string): TaskItem => ({ assignment: "x", role });
+
+	it("joins the specialization tip and the irc coordination suggestion for an async generic fanout", () => {
+		const advisory = composeSpawnAdvisory({
+			agentName: "task",
+			items: [worker(), worker()],
+			depthCapacity: true,
+			ircEnabled: true,
+			willRunAsync: true,
+		});
+		expect(advisory).toContain("`role`");
+		expect(advisory).toContain("Coordinate:");
+	});
+
+	it("drops the coordination suggestion on the sync path but keeps the specialization tip", () => {
+		const advisory = composeSpawnAdvisory({
+			agentName: "task",
+			items: [worker(), worker()],
+			depthCapacity: true,
+			ircEnabled: true,
+			willRunAsync: false,
+		});
+		expect(advisory).toContain("`role`");
+		expect(advisory).not.toContain("Coordinate:");
+	});
+
+	it("omits coordination when irc is unavailable, even async", () => {
+		const advisory = composeSpawnAdvisory({
+			agentName: "task",
+			items: [worker(), worker()],
+			depthCapacity: true,
+			ircEnabled: false,
+			willRunAsync: true,
+		});
+		expect(advisory).toContain("`role`");
+		expect(advisory).not.toContain("Coordinate:");
+	});
+
+	it("returns undefined for a single named spawn", () => {
+		expect(
+			composeSpawnAdvisory({
+				agentName: "reviewer",
+				items: [worker("Auth-flow security reviewer")],
+				depthCapacity: true,
+				ircEnabled: true,
+				willRunAsync: true,
+			}),
+		).toBeUndefined();
+	});
+
+	it("returns undefined at max depth (no spawn capacity)", () => {
+		expect(
+			composeSpawnAdvisory({
+				agentName: "task",
+				items: [worker(), worker()],
+				depthCapacity: false,
+				ircEnabled: true,
+				willRunAsync: true,
+			}),
+		).toBeUndefined();
+	});
+});
diff --git a/packages/coding-agent/test/task/spawn-advisory.test.ts b/packages/coding-agent/test/task/spawn-advisory.test.ts
index 2d74fbbfb..8919d3f24 100644
--- a/packages/coding-agent/test/task/spawn-advisory.test.ts
+++ b/packages/coding-agent/test/task/spawn-advisory.test.ts
@@ -1,6 +1,12 @@
-import { describe, expect, it } from "bun:test";
-import { buildSpecializationAdvisory } from "@oh-my-pi/pi-coding-agent/task";
-import type { TaskItem } from "@oh-my-pi/pi-coding-agent/task/types";
+import { afterEach, beforeEach, describe, expect, it, vi } from "bun:test";
+import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
+import { AgentLifecycleManager } from "@oh-my-pi/pi-coding-agent/registry/agent-lifecycle";
+import { AgentRegistry } from "@oh-my-pi/pi-coding-agent/registry/agent-registry";
+import { buildSpecializationAdvisory, TaskTool } from "@oh-my-pi/pi-coding-agent/task";
+import * as discoveryModule from "@oh-my-pi/pi-coding-agent/task/discovery";
+import * as executorModule from "@oh-my-pi/pi-coding-agent/task/executor";
+import type { AgentDefinition, SingleResult, TaskItem, TaskParams } from "@oh-my-pi/pi-coding-agent/task/types";
+import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
 
 // Contract: the task tool appends an advisory (never a rejection) steering the
 // spawner toward tailored specialists when it spawns generic role-less workers
@@ -36,3 +42,70 @@ describe("buildSpecializationAdvisory", () => {
 		expect(buildSpecializationAdvisory("reviewer", [item()], true)).toBeUndefined();
 	});
 });
+
+// Contract: the advisory rides the task-tool result for an interactive spawner,
+// but a session that opts out (`suppressSpawnAdvisory` — internal/programmatic
+// callers like the commit agent's file-analysis fan-out) gets a clean result so
+// the nudge never contaminates code-consumed evidence.
+describe("task tool advisory gating via suppressSpawnAdvisory", () => {
+	const agent: AgentDefinition = {
+		name: "task",
+		description: "General-purpose task agent",
+		systemPrompt: "You are a task agent.",
+		source: "bundled",
+	};
+
+	beforeEach(() => {
+		AgentRegistry.resetGlobalForTests();
+		AgentLifecycleManager.resetGlobalForTests();
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		AgentLifecycleManager.resetGlobalForTests();
+		AgentRegistry.resetGlobalForTests();
+	});
+
+	function session(suppress: boolean): ToolSession {
+		return {
+			cwd: "/tmp",
+			hasUI: false,
+			suppressSpawnAdvisory: suppress,
+			settings: Settings.isolated({ "task.isolation.mode": "none", "task.batch": false }),
+			getSessionFile: () => null,
+			getSessionSpawns: () => "*",
+		} as unknown as ToolSession;
+	}
+
+	async function spawnText(suppress: boolean): Promise<string> {
+		vi.spyOn(discoveryModule, "discoverAgents").mockResolvedValue({ agents: [agent], projectAgentsDir: null });
+		vi.spyOn(executorModule, "runSubprocess").mockImplementation(
+			async (options): Promise<SingleResult> => ({
+				index: 0,
+				id: options.id ?? "X",
+				agent: "task",
+				agentSource: "bundled",
+				task: "t",
+				assignment: "do the thing",
+				exitCode: 0,
+				output: "done",
+				stderr: "",
+				truncated: false,
+				durationMs: 1,
+				tokens: 0,
+				requests: 1,
+			}),
+		);
+		const tool = await TaskTool.create(session(suppress));
+		const result = await tool.execute("tc", { agent: "task", id: "X", assignment: "do the thing" } as TaskParams);
+		return result.content.find(part => part.type === "text")?.text ?? "";
+	}
+
+	it("appends the specialization advisory for a generic role-less spawn", async () => {
+		expect(await spawnText(false)).toContain("`role`");
+	});
+
+	it("omits the advisory entirely when the session suppresses it", async () => {
+		expect(await spawnText(true)).not.toContain("`role`");
+	});
+});