pi-squad 0.16.3 → 0.16.5

package/src/panel/message-view.ts

@@ -1,7 +1,7 @@
 /**
  * message-view.ts — Scrollable message log for a task.
- * All lines truncated to width. Caps rendered messages to prevent
- * TUI corruption from large message histories.
+ * The durable history is never sliced; only the fixed-height viewport is
+ * collected for the TUI so large histories cannot change component height.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
@@ -9,11 +9,6 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { TaskMessage } from "../types.js";
 import * as store from "../store.js";
 
-/** Max messages to render (most recent). Older messages are skipped. */
-const MAX_MESSAGES = 30;
-/** Max lines per text message before truncation */
-const MAX_TEXT_LINES = 5;
-
 export class MessageView {
 	private theme: Theme;
 	private squadId: string;
@@ -79,21 +74,13 @@ export class MessageView {
 			return pad(header, maxLines);
 		}
 
-		// Only render recent messages to prevent TUI overload
-		const messages = allMessages.slice(-MAX_MESSAGES);
-		const skipped = allMessages.length - messages.length;
-
-		const msgLines: string[] = [];
-		if (skipped > 0) {
-			msgLines.push(fit(th.fg("dim", ` ··· ${skipped} older messages ···`), w));
-			msgLines.push("");
-		}
-		msgLines.push(...this.renderMessages(messages, w));
-
-		// Fixed layout: header + scrollable content + status line = maxLines exactly
+		// Fixed layout: header + scrollable content + status line = maxLines exactly.
+		// Count lazily, then collect only the visible window. This keeps the renderer
+		// bounded without dropping any durable message or body line.
 		const statusLines = 1; // always show status/scroll bar
 		const contentHeight = Math.max(1, maxLines - header.length - statusLines);
-		const maxScroll = Math.max(0, msgLines.length - contentHeight);
+		const messageLineCount = this.countMessageLines(allMessages, w);
+		const maxScroll = Math.max(0, messageLineCount - contentHeight);
 
 		// Auto-scroll to bottom unless user scrolled up
 		if (!this.userScrolled) {
@@ -108,10 +95,10 @@ export class MessageView {
 		// Build output — exact height every time
 		const lines = [...header];
 
-		// Content area: pad to exact contentHeight
-		const visible = msgLines.slice(this.scrollOffset, this.scrollOffset + contentHeight);
+		// Content area: collect and pad to exact contentHeight.
+		const visible = this.collectMessageLines(allMessages, w, this.scrollOffset, contentHeight);
 		while (visible.length < contentHeight) visible.push("");
-		lines.push(...visible.slice(0, contentHeight));
+		lines.push(...visible);
 
 		// Status bar (always present, keeps layout stable)
 		const pct = maxScroll > 0 ? Math.round((this.scrollOffset / maxScroll) * 100) : 100;
@@ -124,10 +111,32 @@ export class MessageView {
 		return lines.slice(0, maxLines);
 	}
 
-	private renderMessages(messages: TaskMessage[], width: number): string[] {
+	private countMessageLines(messages: TaskMessage[], width: number): number {
+		let count = 0;
+		for (const _line of this.iterMessageLines(messages, width)) count++;
+		return count;
+	}
+
+	private collectMessageLines(
+		messages: TaskMessage[],
+		width: number,
+		start: number,
+		limit: number,
+	): string[] {
+		const visible: string[] = [];
+		let index = 0;
+		for (const line of this.iterMessageLines(messages, width)) {
+			if (index++ < start) continue;
+			visible.push(line);
+			if (visible.length >= limit) break;
+		}
+		return visible;
+	}
+
+	private *iterMessageLines(messages: TaskMessage[], width: number): Generator<string> {
 		const th = this.theme;
-		const lines: string[] = [];
 		let lastFrom: string | null = null;
+		let hasOutput = false;
 
 		for (const msg of messages) {
 			if (msg.type === "status" && msg.from === "system" && msg.text === "Agent starting work") continue;
@@ -136,54 +145,47 @@ export class MessageView {
 			lastFrom = msg.from;
 
 			if (showHeader) {
-				if (lines.length > 0) lines.push("");
+				if (hasOutput) yield "";
 				const time = fmtTime(msg.ts);
-				const color = msg.from === "human" ? "accent" : msg.from === "system" ? "dim" : "success";
-				const name = msg.from === "human" ? "YOU" : msg.from;
-				lines.push(fit(` ${th.fg("dim", time)} ${th.fg(color as any, name)}`, width));
+				const color = msg.from === "human" || msg.from === "orchestrator"
+					? "accent"
+					: msg.from === "system" ? "dim" : "success";
+				const name = senderLabel(msg.from);
+				yield fit(` ${th.fg("dim", time)} ${th.fg(color as any, name)}`, width);
+				hasOutput = true;
 			}
 
 			switch (msg.type) {
 				case "tool": {
 					const name = msg.name || msg.text;
-					// Tool args can contain multi-line bash commands — take first line only
+					// Tool args can contain multi-line bash commands — take first line only.
 					const rawArg = (msg.args?.path || msg.args?.command || "").toString();
 					const arg = rawArg.split("\n")[0];
-					lines.push(fit(`   ${th.fg("muted", `→ ${name}${arg ? " " + arg : ""}`)}`, width));
+					yield fit(`   ${th.fg("muted", `→ ${name}${arg ? " " + arg : ""}`)}`, width);
 					break;
 				}
-				case "mention": {
-					lines.push(fit(`   ${th.fg("accent", `@${msg.to || "?"}`)} ${th.fg("dim", msg.text)}`, width));
+				case "mention":
+					yield fit(`   ${th.fg("accent", `@${msg.to || "?"}`)} ${th.fg("dim", msg.text)}`, width);
 					break;
-				}
 				case "text":
 				case "message":
-				case "reply": {
-					const textLines = msg.text.replace(/\r/g, "").split("\n");
-					const show = textLines.slice(0, MAX_TEXT_LINES);
-					for (const tl of show) {
-						// Wrap long lines instead of truncating
-						const wrapped = wrap(`   ${tl}`, width, "      ");
-						lines.push(...wrapped);
-					}
-					if (textLines.length > MAX_TEXT_LINES) {
-						lines.push(fit(`   ${th.fg("dim", `... +${textLines.length - MAX_TEXT_LINES} lines`)}`, width));
+				case "reply":
+					for (const textLine of msg.text.replace(/\r/g, "").split("\n")) {
+						for (const line of wrap(`   ${textLine}`, width, "      ")) yield line;
 					}
 					break;
-				}
 				case "done":
-					lines.push(...wrap(`   ✓ ${msg.text}`, width, "      "));
+					for (const line of wrap(`   ✓ ${msg.text}`, width, "      ")) yield line;
 					break;
 				case "error":
-					lines.push(...wrap(`   ✗ ${msg.text}`, width, "      "));
+					for (const line of wrap(`   ✗ ${msg.text}`, width, "      ")) yield line;
 					break;
 				case "status":
-					lines.push(fit(`   ${th.fg("dim", msg.text)}`, width));
+					yield fit(`   ${th.fg("dim", msg.text)}`, width);
 					break;
 			}
+			hasOutput = true;
 		}
-
-		return lines;
 	}
 }
 
@@ -235,6 +237,12 @@ function stripAnsi(str: string): string {
 	return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 
+function senderLabel(from: string): string {
+	if (from === "human") return "YOU";
+	if (from === "orchestrator") return "ORCHESTRATOR";
+	return from;
+}
+
 function pad(lines: string[], max: number): string[] {
 	while (lines.length < max) lines.push("");
 	return lines.slice(0, max);

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/review.ts

@@ -11,6 +11,18 @@ export interface OrchestratorReviewInput {
 	issues: string[];
 }
 
+/**
+ * Start same-squad rework without discarding completed review evidence.
+ * The next all-tasks-done transition creates a new active pending review.
+ */
+export function beginOrchestratorRework(squad: Squad): void {
+	if (squad.review && squad.review.status !== "pending") {
+		squad.reviewHistory = [...(squad.reviewHistory ?? []), { ...squad.review }];
+	}
+	delete squad.review;
+	squad.status = "running";
+}
+
 /** Move a squad from agent execution into mandatory independent main-session review. */
 export function beginOrchestratorReview(squad: Squad): void {
 	squad.status = "review";
@@ -35,6 +47,9 @@ export function recordOrchestratorReview(squad: Squad, input: OrchestratorReview
 	if (squad.status !== "review" || !squad.review) {
 		throw new Error(`Squad '${squad.id}' is not awaiting orchestrator review`);
 	}
+	if (squad.review.status !== "pending") {
+		throw new Error(`Squad '${squad.id}' review attempt is already ${squad.review.status}; begin same-squad rework before submitting a fresh review`);
+	}
 
 	const contractChecks = cleanList(input.contractChecks);
 	const verificationEvidence = cleanList(input.verificationEvidence);

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]);
+			});
 		}
 	}