pi-squad 0.16.2 → 0.16.4

package/src/panel/squad-widget.ts

@@ -13,7 +13,7 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { Component, TUI } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { TaskStatus } from "../types.js";
+import type { TaskMessage, TaskStatus } from "../types.js";
 import * as store from "../store.js";
 
 function statusIcon(status: TaskStatus, th: Theme): string {
@@ -76,14 +76,33 @@ export function setupSquadWidget(
 		const totalCost = tasks.reduce((sum, t) => sum + t.usage.cost, 0);
 		const doneCount = tasks.filter((t) => t.status === "done").length;
 		const elapsed = Date.now() - new Date(squad.created).getTime();
+		const taskMessages = new Map<string, TaskMessage[]>();
+		const recentOrchestratorByTask = new Map<string, TaskMessage>();
+		const recentMessageKeys: string[] = [];
+		for (const task of tasks) {
+			if (task.status !== "in_progress") continue;
+			const messages = store.loadMessages(state.squadId, task.id);
+			taskMessages.set(task.id, messages);
+			const latest = messages.at(-1);
+			recentMessageKeys.push(`${task.id}:${messages.length}:${latest?.id || latest?.ts || "none"}`);
+			const recentOrchestrator = [...messages.slice(-5)].reverse().find((message) =>
+				message.from === "orchestrator" &&
+				(message.type === "text" || message.type === "message" ||
+					message.type === "reply" || message.type === "mention"),
+			);
+			if (recentOrchestrator) recentOrchestratorByTask.set(task.id, recentOrchestrator);
+		}
 
 		const sIcon = squad.status === "done" ? th.fg("success", "✓")
 			: squad.status === "failed" ? th.fg("error", "✗")
 			: squad.status === "review" ? th.fg("warning", "◆")
 			: th.fg("warning", "⏳");
 
+		const orchestratorSignal = recentOrchestratorByTask.size > 0
+			? ` ${th.fg("accent", `✉ ${recentOrchestratorByTask.size > 1 ? recentOrchestratorByTask.size + " " : ""}ORCH`)}`
+			: "";
 		lines.push(
-			`${sIcon} ${th.fg("accent", "squad")} ${th.fg("dim", squad.goal.slice(0, 35))} ` +
+			`${sIcon} ${th.fg("accent", "squad")}${orchestratorSignal} ${th.fg("dim", squad.goal.slice(0, 35))} ` +
 			`${th.fg("muted", `${doneCount}/${tasks.length}`)} ` +
 			`${th.fg("dim", `$${totalCost.toFixed(2)}`)} ` +
 			`${th.fg("dim", formatElapsed(elapsed))} ` +
@@ -111,13 +130,19 @@ export function setupSquadWidget(
 				const runningFor = task.started ? Date.now() - new Date(task.started).getTime() : 0;
 				const timeColor = runningFor > 180_000 ? "warning" : "dim";
 				line += ` ${th.fg(timeColor as any, formatElapsed(runningFor))}`;
-				const messages = store.loadMessages(state.squadId!, task.id);
-				const lastTool = [...messages].reverse().find(m => m.type === "tool");
-				if (lastTool) {
-					const rawDetail = (lastTool.args?.path || lastTool.args?.command || "").toString();
-					const detail = rawDetail.split("\n")[0]; // first line only
-					const toolStr = `→ ${lastTool.name || lastTool.text}`;
-					line += ` ${th.fg("dim", (detail ? `${toolStr} ${detail}` : toolStr).slice(0, 30))}`;
+				const messages = taskMessages.get(task.id) || [];
+				const recentOrchestrator = recentOrchestratorByTask.get(task.id);
+				if (recentOrchestrator) {
+					const preview = recentOrchestrator.text.split("\n")[0].slice(0, 24);
+					line += ` ${th.fg("accent", "← ORCH")} ${th.fg("dim", preview)}`;
+				} else {
+					const lastTool = [...messages].reverse().find(m => m.type === "tool");
+					if (lastTool) {
+						const rawDetail = (lastTool.args?.path || lastTool.args?.command || "").toString();
+						const detail = rawDetail.split("\n")[0]; // first line only
+						const toolStr = `→ ${lastTool.name || lastTool.text}`;
+						line += ` ${th.fg("dim", (detail ? `${toolStr} ${detail}` : toolStr).slice(0, 30))}`;
+					}
 				}
 			} else if (task.status === "blocked") {
 				const blockers = task.depends.filter((d) => {
@@ -136,7 +161,7 @@ export function setupSquadWidget(
 			lines.push(`  ${th.fg("dim", `  +${tasks.length - maxVisible} more · ^q detail`)}`);
 		}
 
-		const cacheKey = `${squad.status}:${tasks.map(t => `${t.id}=${t.status}:${t.usage.turns}`).join(",")}`;
+		const cacheKey = `${squad.status}:${tasks.map(t => `${t.id}=${t.status}:${t.usage.turns}`).join(",")}:${recentMessageKeys.join(",")}`;
 
 		const statusText = squad.status === "done"
 			? th.fg("success", `✓ squad ${doneCount}/${tasks.length}`)

package/src/panel/task-list.ts

@@ -200,15 +200,25 @@ export class TaskListView {
 		const recent = messages.slice(-3);
 
 		for (const msg of recent) {
-			if (msg.type === "tool") {
+			const isConversation = msg.type === "text" || msg.type === "message" ||
+				msg.type === "reply" || msg.type === "mention";
+			if (msg.from === "orchestrator" && isConversation) {
+				const preview = msg.text.split("\n")[0];
+				lines.push(truncateToWidth(
+					` ${th.fg("accent", "ORCHESTRATOR")} ${th.fg("dim", `"${preview}"`)}`,
+					width,
+					"…",
+				));
+			} else if (msg.type === "tool") {
 				const toolStr = `→ ${msg.name || msg.text}`;
 				const rawArgs = (msg.args?.path || msg.args?.command || "").toString();
 				const argsStr = rawArgs.split("\n")[0]; // first line only
 				const preview = argsStr ? `${toolStr} ${argsStr}` : toolStr;
 				lines.push(truncateToWidth(` ${th.fg("muted", preview)}`, width, "…"));
-			} else if (msg.type === "text" && msg.from !== "system") {
+			} else if (isConversation && msg.from !== "system") {
 				const preview = msg.text.split("\n")[0];
-				lines.push(truncateToWidth(` ${th.fg("dim", `"${preview}"`)}`, width, "…"));
+				const sender = msg.from === "human" ? "YOU" : msg.from;
+				lines.push(truncateToWidth(` ${th.fg("dim", `${sender}: "${preview}"`)}`, width, "…"));
 			}
 		}
 

package/src/router.ts

@@ -2,8 +2,8 @@
  * router.ts — @mention parsing and cross-agent message delivery.
  *
  * Parses assistant text for @agentname patterns.
- * Routes messages to target agents via steer() if running,
- * or queues them for delivery on next spawn.
+ * Routes messages to exact target tasks via steer() if running,
+ * or a durable task-owned mailbox for delivery on next spawn.
  */
 
 import type { AgentPool } from "./agent-pool.js";
@@ -83,30 +83,41 @@ export class Router {
 			text: message,
 		});
 
-		// Find if target agent is running
-		const targetTaskId = this.pool.getTaskIdForAgent(targetAgent);
-
-		if (targetTaskId && this.pool.isRunning(targetTaskId)) {
-			// Target is running — steer them
-			const steerMessage = `[squad] Message from @${fromAgent} (working on ${sourceTaskId}):\n${message}`;
-			this.pool.steer(targetTaskId, steerMessage);
+		// Agent-name mentions are safe only when exactly one live task owns that
+		// role. Multiple concurrent same-role tasks must never receive guessed mail.
+		const liveTargets = store.loadAllTasks(this.squadId).filter(
+			(task) => task.agent === targetAgent && this.pool.isRunning(task.id),
+		);
+		const targetTaskId = liveTargets.length === 1 ? liveTargets[0].id : undefined;
 
-			// Log in target task too
-			store.appendMessage(this.squadId, targetTaskId, {
+		if (targetTaskId) {
+			const queued = store.queueTaskMessage(this.squadId, targetTaskId, {
 				ts: store.now(),
 				from: fromAgent,
 				type: "mention",
 				to: targetAgent,
 				text: message,
 			});
+			const steerMessage = `[squad] Message from @${fromAgent} (working on ${sourceTaskId}):\n${message}`;
+			void this.pool.steer(targetTaskId, steerMessage).then((delivered) => {
+				if (delivered) store.acknowledgeTaskMessages(this.squadId, targetTaskId, [queued.id]);
+			});
 			return false;
 		}
 
 		const targetTasks = store.loadAllTasks(this.squadId).filter((task) => task.agent === targetAgent);
-		const hasFutureRun = targetTasks.some((task) =>
-			task.status === "pending" || task.status === "blocked" || task.status === "suspended" || task.status === "in_progress",
+		const futureTasks = targetTasks.filter((task) =>
+			task.status === "in_progress" || task.status === "pending" || task.status === "suspended" || task.status === "blocked",
 		);
-		if (!hasFutureRun) {
+		const interrupted = futureTasks.filter((task) => task.status === "in_progress");
+		// Never guess between two tasks assigned to the same role. A uniquely
+		// interrupted task is authoritative; otherwise only one future task is safe.
+		const futureTask = interrupted.length === 1
+			? interrupted[0]
+			: futureTasks.length === 1
+				? futureTasks[0]
+				: undefined;
+		if (futureTasks.length === 0) {
 			const completed = targetTasks.filter((task) => task.status === "done" && task.output);
 			if (completed.length > 0) {
 				const durableReply = [
@@ -120,21 +131,20 @@ export class Router {
 					to: fromAgent,
 					text: durableReply,
 				};
-				store.appendMessage(this.squadId, sourceTaskId, reply);
+				const queued = store.queueTaskMessage(this.squadId, sourceTaskId, reply);
 				if (this.pool.isRunning(sourceTaskId)) {
-					this.pool.steer(sourceTaskId, durableReply);
-				} else {
-					this.pool.queueMessage(fromAgent, reply);
+					void this.pool.steer(sourceTaskId, durableReply).then((delivered) => {
+						if (delivered) store.acknowledgeTaskMessages(this.squadId, sourceTaskId, [queued.id]);
+					});
 				}
 				return true;
 			}
 		}
 
-		// Target has future work and may spawn again — queue for that run. If the
-		// target is terminal with no output, do not create an undeliverable queue;
-		// leave the blocker unresolved so it escalates to the main orchestrator.
-		if (hasFutureRun) {
-			this.pool.queueMessage(targetAgent, {
+		// Target has future work and may spawn again. Bind the message to exactly
+		// one durable task, never to the shared role name.
+		if (futureTask) {
+			store.queueTaskMessage(this.squadId, futureTask.id, {
 				ts: store.now(),
 				from: fromAgent,
 				type: "mention",
@@ -149,7 +159,7 @@ export class Router {
 	 * Route a human message to an agent.
 	 */
 	routeHumanMessage(taskId: string, message: string): void {
-		store.appendMessage(this.squadId, taskId, {
+		const queued = store.queueTaskMessage(this.squadId, taskId, {
 			ts: store.now(),
 			from: "human",
 			type: "message",
@@ -157,17 +167,9 @@ export class Router {
 		});
 
 		if (this.pool.isRunning(taskId)) {
-			this.pool.steer(taskId, `[squad] Human: ${message}`);
-		} else {
-			const task = store.loadTask(this.squadId, taskId);
-			if (task) {
-				this.pool.queueMessage(task.agent, {
-					ts: store.now(),
-					from: "human",
-					type: "message",
-					text: message,
-				});
-			}
+			void this.pool.steer(taskId, `[squad] Human: ${message}`).then((delivered) => {
+				if (delivered) store.acknowledgeTaskMessages(this.squadId, taskId, [queued.id]);
+			});
 		}
 	}