@clinebot/core 0.0.33 → 0.0.35

package/src/{team → extensions/tools/team}/multi-agent.ts

@@ -138,6 +138,23 @@ export interface SpawnTeammateOptions {
 	config: TeamMemberConfig;
 }
 
+function isAbortLikeError(error: unknown): boolean {
+	if (
+		typeof DOMException !== "undefined" &&
+		error instanceof DOMException &&
+		error.name === "AbortError"
+	) {
+		return true;
+	}
+	if (!(error instanceof Error)) {
+		return false;
+	}
+	return (
+		error.name === "AbortError" ||
+		error.message.toLowerCase().includes("aborted")
+	);
+}
+
 // =============================================================================
 // AgentTeam
 // =============================================================================
@@ -484,6 +501,7 @@ interface TeamMemberState extends TeamMemberSnapshot {
 	runningCount: number;
 	lastMissionStep: number;
 	lastMissionAt: number;
+	pendingSteerMessage?: string;
 }
 
 export class AgentTeamsRuntime {
@@ -568,8 +586,6 @@ export class AgentTeamsRuntime {
 	listTaskItems(options?: {
 		status?: TeamTaskStatus;
 		assignee?: string;
-		unassignedOnly?: boolean;
-		readyOnly?: boolean;
 	}): TeamTaskListItem[] {
 		return Array.from(this.tasks.values())
 			.map((task) => {
@@ -590,12 +606,6 @@ export class AgentTeamsRuntime {
 				if (options?.assignee && task.assignee !== options.assignee) {
 					return false;
 				}
-				if (options?.unassignedOnly && !!task.assignee) {
-					return false;
-				}
-				if (options?.readyOnly && !task.isReady) {
-					return false;
-				}
 				return true;
 			});
 	}
@@ -825,6 +835,15 @@ export class AgentTeamsRuntime {
 		const wrappedConfig: TeamMemberConfig = {
 			...config,
 			apiTimeoutMs: TEAMMATE_API_TIMEOUT_MS,
+			consumePendingUserMessage: () => {
+				const member = this.members.get(agentId);
+				if (!member || !member.pendingSteerMessage) {
+					return undefined;
+				}
+				const message = member.pendingSteerMessage;
+				member.pendingSteerMessage = undefined;
+				return message;
+			},
 			onEvent: (event: AgentEvent) => {
 				config.onEvent?.(event);
 				this.emitEvent({ type: TeamMessageType.AgentEvent, agentId, event });
@@ -870,7 +889,13 @@ export class AgentTeamsRuntime {
 		if (!member || member.role !== "teammate") {
 			throw new Error(`Teammate "${agentId}" was not found`);
 		}
-		member.agent?.abort();
+		try {
+			member.agent?.abort();
+		} catch (error) {
+			if (!isAbortLikeError(error)) {
+				throw error;
+			}
+		}
 		member.status = "stopped";
 		this.emitEvent({ type: TeamMessageType.TeammateShutdown, agentId, reason });
 	}
@@ -986,9 +1011,17 @@ export class AgentTeamsRuntime {
 		this.emitEvent({ type: TeamMessageType.TaskStart, agentId, message });
 
 		try {
+			const unreadMail = this.listMailbox(agentId, {
+				unreadOnly: true,
+				markRead: true,
+			});
+			const enrichedMessage =
+				unreadMail.length > 0
+					? `${this.buildMailboxNotification(unreadMail)}\n\n${message}`
+					: message;
 			const result = options?.continueConversation
-				? await member.agent.continue(message)
-				: await member.agent.run(message);
+				? await member.agent.continue(enrichedMessage)
+				: await member.agent.run(enrichedMessage);
 			this.emitEvent({ type: TeamMessageType.TaskEnd, agentId, result });
 			this.recordProgressStep(
 				agentId,
@@ -1254,7 +1287,8 @@ export class AgentTeamsRuntime {
 		if (!this.members.has(fromAgentId)) {
 			throw new Error(`Unknown sender "${fromAgentId}"`);
 		}
-		if (!this.members.has(toAgentId)) {
+		const recipient = this.members.get(toAgentId);
+		if (!recipient) {
 			throw new Error(`Unknown recipient "${toAgentId}"`);
 		}
 		const message: TeamMailboxMessage = {
@@ -1272,6 +1306,13 @@ export class AgentTeamsRuntime {
 			type: TeamMessageType.TeamMessage,
 			message: { ...message },
 		});
+		if (
+			recipient.role === "teammate" &&
+			recipient.runningCount > 0 &&
+			recipient.agent
+		) {
+			recipient.pendingSteerMessage = `[MAILBOX] You got a message from ${fromAgentId}. Subject: "${subject}". Use the team_read_mailbox tool to read it at your convenience.`;
+		}
 		return { ...message };
 	}
 
@@ -1279,15 +1320,14 @@ export class AgentTeamsRuntime {
 		fromAgentId: string,
 		subject: string,
 		body: string,
-		options?: { includeLead?: boolean; taskId?: string },
+		options?: { taskId?: string },
 	): TeamMailboxMessage[] {
-		const includeLead = options?.includeLead ?? false;
 		const messages: TeamMailboxMessage[] = [];
 		for (const member of this.members.values()) {
 			if (member.agentId === fromAgentId) {
 				continue;
 			}
-			if (!includeLead && member.role === "lead") {
+			if (member.role === "lead") {
 				continue;
 			}
 			messages.push(
@@ -1458,7 +1498,13 @@ export class AgentTeamsRuntime {
 
 		for (const member of this.members.values()) {
 			if (member.role === "teammate") {
-				member.agent?.abort();
+				try {
+					member.agent?.abort();
+				} catch (error) {
+					if (!isAbortLikeError(error)) {
+						throw error;
+					}
+				}
 			}
 		}
 
@@ -1526,7 +1572,7 @@ export class AgentTeamsRuntime {
 			this.appendMissionLog({
 				agentId,
 				kind: "done",
-				summary: `Run completed after ${event.iterations} iteration(s)`,
+				summary: `Completed a delegated run (${event.iterations} iterations)`,
 			});
 			return;
 		}
@@ -1638,6 +1684,23 @@ export class AgentTeamsRuntime {
 		});
 	}
 
+	private buildMailboxNotification(messages: TeamMailboxMessage[]): string {
+		if (messages.length === 0) {
+			return "";
+		}
+		const lines: string[] = [
+			`[MAILBOX] You have ${messages.length} unread message(s):`,
+		];
+		for (const msg of messages) {
+			lines.push(
+				`--- Message from ${msg.fromAgentId} | subject: ${msg.subject} ---`,
+			);
+			lines.push(msg.body);
+		}
+		lines.push("---");
+		return lines.join("\n");
+	}
+
 	private emitEvent(event: TeamEvent): void {
 		try {
 			this.onTeamEvent?.(event);

package/src/{team → extensions/tools/team}/spawn-agent-tool.test.ts

@@ -180,7 +180,6 @@ describe("createSpawnAgentTool", () => {
 				{
 					systemPrompt: "System",
 					task: "Fail task",
-					maxIterations: 6,
 				},
 				{
 					agentId: "parent-2",
@@ -197,11 +196,6 @@ describe("createSpawnAgentTool", () => {
 				error: expect.any(Error),
 			}),
 		);
-		expect(agentConstructorSpy).toHaveBeenCalledWith(
-			expect.objectContaining({
-				maxIterations: 6,
-			}),
-		);
 	});
 
 	it("leaves maxIterations unset when neither input nor default is provided", async () => {

package/src/{team → extensions/tools/team}/spawn-agent-tool.ts

@@ -32,12 +32,6 @@ export const SpawnAgentInputSchema = z.object({
 		.string()
 		.describe("System prompt defining the sub-agent's behavior"),
 	task: z.string().describe("Task for the sub-agent to complete"),
-	maxIterations: z
-		.number()
-		.int()
-		.min(1)
-		.optional()
-		.describe("Max iterations for the sub-agent"),
 });
 
 export type SpawnAgentInput = z.infer<typeof SpawnAgentInputSchema>;
@@ -136,7 +130,7 @@ export function createSpawnAgentTool(
 				prompt: input.systemPrompt,
 				configProvider: config.configProvider,
 				tools,
-				maxIterations: input.maxIterations ?? config.defaultMaxIterations,
+				maxIterations: config.defaultMaxIterations,
 				parentAgentId: context.agentId,
 				abortSignal: context.abortSignal,
 				onEvent: config.onSubAgentEvent,

package/src/{team → extensions/tools/team}/subagent-prompts.ts

@@ -11,7 +11,7 @@ export function buildTeammateSystemPrompt(
 	}
 
 	return buildClineSystemPrompt({
-		ide: config.clineIdeName?.trim() || "Terminal Shell",
+		ide: config.clineIdeName?.trim() || "Terminal",
 		workspaceRoot: config.cwd?.trim() || "/",
 		providerId: config.providerId,
 		rules: `# Team Teammate Role\n${trimmedPrompt}`,
@@ -31,7 +31,7 @@ export function buildSubAgentSystemPrompt(
 	}
 
 	return buildClineSystemPrompt({
-		ide: "Terminal Shell",
+		ide: config.clineIdeName || "Terminal",
 		workspaceRoot: config.cwd?.trim() || "/",
 		providerId: config.providerId,
 		overridePrompt: trimmedPrompt,

package/src/{team → extensions/tools/team}/team-tools.test.ts

@@ -69,8 +69,10 @@ describe("createAgentTeamsTools schema surface", () => {
 		const createOutcome = tools.find(
 			(tool) => tool.name === "team_create_outcome",
 		);
-		const teamAwaitRun = tools.find((tool) => tool.name === "team_await_run");
-		const teamLogUpdate = tools.find((tool) => tool.name === "team_log_update");
+		const teamAwaitRuns = tools.find((tool) => tool.name === "team_await_runs");
+		const teamLogUpdate = tools.find(
+			(tool) => tool.name === "team_mission_log",
+		);
 
 		expect(spawn?.inputSchema.type).toBe("object");
 		const teamTaskSchema = teamTask?.inputSchema as
@@ -85,7 +87,7 @@ describe("createAgentTeamsTools schema surface", () => {
 		expect(teamTaskSchema?.required).toEqual(["action"]);
 		expect(send?.inputSchema.type).toBe("object");
 		expect(createOutcome?.inputSchema.type).toBe("object");
-		expect(teamAwaitRun?.inputSchema.type).toBe("object");
+		expect(teamAwaitRuns?.inputSchema.type).toBe("object");
 		const schema = teamLogUpdate?.inputSchema as
 			| { properties: Record<string, unknown>; required: unknown[] }
 			| undefined;
@@ -243,7 +245,7 @@ describe("createAgentTeamsTools schema surface", () => {
 		});
 	});
 
-	it("rejects fields that do not belong to the selected action", async () => {
+	it("ignores non-create fields for action=create and reports them back", async () => {
 		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
 		const tools = createAgentTeamsTools({
 			runtime,
@@ -252,13 +254,18 @@ describe("createAgentTeamsTools schema surface", () => {
 		});
 		const teamTask = tools.find((tool) => tool.name === "team_task");
 		expect(teamTask).toBeDefined();
+		if (!teamTask) {
+			throw new Error("Expected team_task tool to be defined");
+		}
 
 		await expect(
-			teamTask?.execute(
+			teamTask.execute(
 				{
-					action: "claim",
-					taskId: "task_0001",
-					title: "should not be here",
+					action: "create",
+					title: "Draft TypeScript haiku",
+					description: "Write a concise haiku",
+					status: "pending",
+					summary: "not used",
 				},
 				{
 					agentId: "lead",
@@ -266,7 +273,13 @@ describe("createAgentTeamsTools schema surface", () => {
 					iteration: 1,
 				},
 			),
-		).rejects.toThrow('Field "title" is not allowed when action=claim');
+		).resolves.toMatchObject({
+			action: "create",
+			status: "pending",
+			taskId: expect.stringMatching(/^task_/),
+			ignoredFields: ["status", "summary"],
+			note: "Ignored fields for action=create: status, summary",
+		});
 	});
 
 	it("defaults requiredSections for team_create_outcome", async () => {
@@ -530,7 +543,7 @@ describe("createAgentTeamsTools runtime behavior", () => {
 		);
 	});
 
-	it("throws from team_await_run when async delegated run fails", async () => {
+	it("throws from team_await_runs when a requested async delegated run fails", async () => {
 		const runtime = {
 			awaitRun: vi.fn(async () => ({
 				id: "run_0001",
@@ -544,11 +557,11 @@ describe("createAgentTeamsTools runtime behavior", () => {
 			requesterId: "lead",
 			teammateConfigProvider: makeTeammateConfigProvider(),
 		});
-		const awaitRun = tools.find((tool) => tool.name === "team_await_run");
-		expect(awaitRun).toBeDefined();
+		const awaitRuns = tools.find((tool) => tool.name === "team_await_runs");
+		expect(awaitRuns).toBeDefined();
 
 		await expect(
-			awaitRun?.execute(
+			awaitRuns?.execute(
 				{ runId: "run_0001" },
 				{
 					agentId: "lead",
@@ -559,7 +572,7 @@ describe("createAgentTeamsTools runtime behavior", () => {
 		).rejects.toThrow('Run "run_0001" failed: Authentication failed');
 	});
 
-	it("throws from team_await_all_runs when any delegated run is not successful", async () => {
+	it("throws from team_await_runs when any delegated run is not successful in all-runs mode", async () => {
 		const runtime = {
 			awaitAllRuns: vi.fn(async () => [
 				{ id: "run_ok", status: "completed" },
@@ -572,13 +585,11 @@ describe("createAgentTeamsTools runtime behavior", () => {
 			requesterId: "lead",
 			teammateConfigProvider: makeTeammateConfigProvider(),
 		});
-		const awaitAllRuns = tools.find(
-			(tool) => tool.name === "team_await_all_runs",
-		);
-		expect(awaitAllRuns).toBeDefined();
+		const awaitRuns = tools.find((tool) => tool.name === "team_await_runs");
+		expect(awaitRuns).toBeDefined();
 
 		await expect(
-			awaitAllRuns?.execute(
+			awaitRuns?.execute(
 				{},
 				{
 					agentId: "lead",
@@ -591,7 +602,7 @@ describe("createAgentTeamsTools runtime behavior", () => {
 		);
 	});
 
-	it("returns compact summaries from team_await_run without full teammate transcripts", async () => {
+	it("returns compact summaries from team_await_runs without full teammate transcripts", async () => {
 		const runtime = {
 			awaitRun: vi.fn(async () => ({
 				id: "run_0001",
@@ -633,10 +644,10 @@ describe("createAgentTeamsTools runtime behavior", () => {
 			requesterId: "lead",
 			teammateConfigProvider: makeTeammateConfigProvider(),
 		});
-		const awaitRun = tools.find((tool) => tool.name === "team_await_run");
+		const awaitRuns = tools.find((tool) => tool.name === "team_await_runs");
 
 		await expect(
-			awaitRun?.execute(
+			awaitRuns?.execute(
 				{ runId: "run_0001" },
 				{
 					agentId: "lead",
@@ -728,22 +739,122 @@ describe("createAgentTeamsTools runtime behavior", () => {
 		]);
 	});
 
-	it("sets long timeout for team await tools", () => {
+	it("sets long timeout for team await tool", () => {
 		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
 		const tools = createAgentTeamsTools({
 			runtime,
 			requesterId: "lead",
 			teammateConfigProvider: makeTeammateConfigProvider(),
 		});
-		const awaitRun = tools.find((tool) => tool.name === "team_await_run");
-		const awaitAllRuns = tools.find(
-			(tool) => tool.name === "team_await_all_runs",
+		const awaitRuns = tools.find((tool) => tool.name === "team_await_runs");
+		expect(awaitRuns?.timeoutMs).toBe(60 * 60 * 1000);
+	});
+
+	it("deduplicates concurrent sync team_run_task calls to the same agent", async () => {
+		let resolveRoute!: (value: { text: string; iterations: number }) => void;
+		const routePromise = new Promise<{ text: string; iterations: number }>(
+			(resolve) => {
+				resolveRoute = resolve;
+			},
 		);
-		expect(awaitRun?.timeoutMs).toBe(60 * 60 * 1000);
-		expect(awaitAllRuns?.timeoutMs).toBe(60 * 60 * 1000);
+		const routeToTeammate = vi.fn(() => routePromise);
+		const runtime = {
+			routeToTeammate,
+			getMemberRole: vi.fn(() => "lead"),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const runTask = tools.find((tool) => tool.name === "team_run_task");
+		expect(runTask).toBeDefined();
+		if (!runTask) {
+			throw new Error("Expected team_run_task tool to be defined");
+		}
+
+		const ctx = { agentId: "lead", conversationId: "conv-1", iteration: 1 };
+		const input = {
+			agentId: "educator",
+			task: "Explain probability",
+			runMode: "sync",
+		};
+
+		// Fire two concurrent sync calls to the same agent
+		const call1 = runTask.execute(input, ctx);
+		const call2 = runTask.execute(input, ctx);
+
+		// Second call should throw with duplicate detection error
+		await expect(call2).rejects.toThrow(
+			'Duplicate team_run_task call detected for agent "educator"',
+		);
+
+		// Only one routeToTeammate call should have been made
+		expect(routeToTeammate).toHaveBeenCalledTimes(1);
+
+		// Now resolve the first call
+		resolveRoute({ text: "Probability explained", iterations: 3 });
+		const result1 = (await call1) as { text?: string; iterations?: number };
+		expect(result1.text).toBe("Probability explained");
+		expect(result1.iterations).toBe(3);
+	});
+
+	it("allows concurrent sync team_run_task calls to different agents", async () => {
+		let resolveRoute1!: (value: { text: string; iterations: number }) => void;
+		let resolveRoute2!: (value: { text: string; iterations: number }) => void;
+		const routeToTeammate = vi.fn((agentId: string) => {
+			if (agentId === "educator") {
+				return new Promise<{ text: string; iterations: number }>((resolve) => {
+					resolveRoute1 = resolve;
+				});
+			}
+			return new Promise<{ text: string; iterations: number }>((resolve) => {
+				resolveRoute2 = resolve;
+			});
+		});
+		const runtime = {
+			routeToTeammate,
+			getMemberRole: vi.fn(() => "lead"),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const runTask = tools.find((tool) => tool.name === "team_run_task");
+		expect(runTask).toBeDefined();
+		if (!runTask) {
+			throw new Error("Expected team_run_task tool to be defined");
+		}
+
+		const ctx = { agentId: "lead", conversationId: "conv-1", iteration: 1 };
+
+		// Fire sync calls to two different agents - both should proceed
+		const call1 = runTask.execute(
+			{ agentId: "educator", task: "Explain probability", runMode: "sync" },
+			ctx,
+		);
+		const call2 = runTask.execute(
+			{ agentId: "assessor", task: "Evaluate answer", runMode: "sync" },
+			ctx,
+		);
+
+		// Both should have called routeToTeammate
+		expect(routeToTeammate).toHaveBeenCalledTimes(2);
+
+		// Resolve both
+		resolveRoute1({ text: "Explained", iterations: 2 });
+		resolveRoute2({ text: "Evaluated", iterations: 1 });
+
+		const result1 = (await call1) as { text?: string };
+		const result2 = (await call2) as { text?: string };
+		expect(result1.text).toBe("Explained");
+		expect(result2.text).toBe("Evaluated");
 	});
 
-	it("lists ready-to-claim tasks through team_task list action", async () => {
+	it("lists team tasks through team_task list action", async () => {
 		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
 		const tools = createAgentTeamsTools({
 			runtime,
@@ -781,7 +892,7 @@ describe("createAgentTeamsTools runtime behavior", () => {
 
 		await expect(
 			teamTask?.execute(
-				{ action: "list", readyOnly: true },
+				{ action: "list" },
 				{
 					agentId: "lead",
 					conversationId: "conv-1",
@@ -796,6 +907,11 @@ describe("createAgentTeamsTools runtime behavior", () => {
 					isReady: true,
 					blockedBy: [],
 				}),
+				expect.objectContaining({
+					title: "Blocked task",
+					isReady: false,
+					blockedBy: [first.taskId],
+				}),
 			],
 		});
 	});