pi-squad 0.1.0

package/src/monitor.ts

@@ -0,0 +1,204 @@
+/**
+ * monitor.ts — Health monitoring for running agents.
+ *
+ * Periodically checks all running agents for:
+ * - Idle timeout (no output for N minutes)
+ * - Stuck detection (no output for longer)
+ * - Loop detection (same tool call repeated)
+ * - Hard ceiling (max total runtime)
+ * - File conflict warnings
+ */
+
+import type { AgentPool } from "./agent-pool.js";
+import type { HealthStatus } from "./types.js";
+
+// ============================================================================
+// Config
+// ============================================================================
+
+const IDLE_WARNING_MS = 3 * 60 * 1000; // 3 min no output → warn
+const STUCK_TIMEOUT_MS = 5 * 60 * 1000; // 5 min no output → intervene
+const HARD_CEILING_MS = 30 * 60 * 1000; // 30 min total → force stop
+const LOOP_THRESHOLD = 5; // same tool call 5x → looping
+const POLL_INTERVAL_MS = 30 * 1000; // check every 30s
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type MonitorActionType = "steer" | "abort" | "escalate";
+
+export interface MonitorAction {
+	type: MonitorActionType;
+	taskId: string;
+	agentName: string;
+	reason: string;
+	message: string;
+}
+
+export type MonitorActionListener = (action: MonitorAction) => void;
+
+// ============================================================================
+// Monitor
+// ============================================================================
+
+export class Monitor {
+	private pool: AgentPool;
+	private squadId: string;
+	private interval: ReturnType<typeof setInterval> | null = null;
+	private listeners: MonitorActionListener[] = [];
+	/** Track which agents have been warned (to avoid repeated warnings) */
+	private warned = new Set<string>();
+	/** Track which agents have been steered for stuck (to avoid repeated steers) */
+	private stuckSteered = new Set<string>();
+
+	constructor(pool: AgentPool, squadId: string) {
+		this.pool = pool;
+		this.squadId = squadId;
+	}
+
+	/** Subscribe to monitor actions */
+	onAction(listener: MonitorActionListener): () => void {
+		this.listeners.push(listener);
+		return () => {
+			const idx = this.listeners.indexOf(listener);
+			if (idx !== -1) this.listeners.splice(idx, 1);
+		};
+	}
+
+	private emit(action: MonitorAction): void {
+		for (const listener of this.listeners) {
+			try {
+				listener(action);
+			} catch {
+				/* ignore */
+			}
+		}
+	}
+
+	/** Start periodic health checks */
+	start(): void {
+		if (this.interval) return;
+		this.interval = setInterval(() => this.checkAll(), POLL_INTERVAL_MS);
+	}
+
+	/** Stop monitoring */
+	stop(): void {
+		if (this.interval) {
+			clearInterval(this.interval);
+			this.interval = null;
+		}
+		this.warned.clear();
+		this.stuckSteered.clear();
+	}
+
+	/** Check all running agents */
+	private checkAll(): void {
+		for (const agentName of this.pool.getRunningAgents()) {
+			const taskId = this.pool.getTaskIdForAgent(agentName);
+			if (!taskId) continue;
+
+			const activity = this.pool.getActivity(taskId);
+			if (!activity) continue;
+
+			const health = this.checkHealth(activity);
+			this.handleHealth(taskId, agentName, health);
+		}
+	}
+
+	/** Determine health status from activity data */
+	checkHealth(activity: {
+		lastOutputTs: number;
+		startedAt: number;
+		recentToolCalls: string[];
+	}): HealthStatus {
+		const now = Date.now();
+		const idleMs = now - activity.lastOutputTs;
+		const totalMs = now - activity.startedAt;
+
+		// Loop detection: last N tool calls are identical
+		const recent = activity.recentToolCalls.slice(-LOOP_THRESHOLD);
+		if (recent.length >= LOOP_THRESHOLD) {
+			const unique = new Set(recent);
+			if (unique.size === 1) return "looping";
+		}
+
+		if (totalMs >= HARD_CEILING_MS) return "exceeded_ceiling";
+		if (idleMs >= STUCK_TIMEOUT_MS) return "stuck";
+		if (idleMs >= IDLE_WARNING_MS) return "idle_warning";
+
+		return "healthy";
+	}
+
+	/** Take action based on health status */
+	private handleHealth(taskId: string, agentName: string, status: HealthStatus): void {
+		switch (status) {
+			case "healthy":
+				// Clear warning flags
+				this.warned.delete(taskId);
+				this.stuckSteered.delete(taskId);
+				break;
+
+			case "idle_warning":
+				if (!this.warned.has(taskId)) {
+					this.warned.add(taskId);
+					this.emit({
+						type: "steer",
+						taskId,
+						agentName,
+						reason: "idle",
+						message:
+							"[squad] You've been idle for a few minutes. What's your status? If you're stuck, say so and I'll help.",
+					});
+				}
+				break;
+
+			case "stuck":
+				if (!this.stuckSteered.has(taskId)) {
+					this.stuckSteered.add(taskId);
+					this.emit({
+						type: "steer",
+						taskId,
+						agentName,
+						reason: "stuck",
+						message:
+							"[squad] You appear stuck — no output for 5 minutes. " +
+							"Summarize what you've done and what's blocking you. " +
+							"If you can't proceed, state what you need.",
+					});
+				} else {
+					// Already steered once, escalate
+					this.emit({
+						type: "escalate",
+						taskId,
+						agentName,
+						reason: `Agent ${agentName} stuck on ${taskId} — no output after intervention`,
+						message: "",
+					});
+				}
+				break;
+
+			case "looping":
+				this.emit({
+					type: "steer",
+					taskId,
+					agentName,
+					reason: "looping",
+					message:
+						"[squad] You're repeating the same action in a loop. " +
+						"Stop and reassess your approach. Try a different strategy.",
+				});
+				break;
+
+			case "exceeded_ceiling":
+				this.emit({
+					type: "abort",
+					taskId,
+					agentName,
+					reason: `Agent ${agentName} exceeded time ceiling on ${taskId}`,
+					message: "",
+				});
+				break;
+		}
+	}
+}

package/src/panel/message-view.ts

@@ -0,0 +1,232 @@
+/**
+ * message-view.ts — Scrollable message log for a task.
+ * Shows tool calls, agent text, @mentions, human messages.
+ */
+
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import type { TaskMessage } from "../types.js";
+import * as store from "../store.js";
+
+// ============================================================================
+// Message View
+// ============================================================================
+
+export class MessageView {
+	private theme: Theme;
+	private squadId: string;
+	private taskId: string | null = null;
+	private scrollOffset = 0;
+
+	constructor(theme: Theme, squadId: string) {
+		this.theme = theme;
+		this.squadId = squadId;
+	}
+
+	setTaskId(taskId: string): void {
+		this.taskId = taskId;
+		this.scrollOffset = 0;
+	}
+
+	getTaskId(): string | null {
+		return this.taskId;
+	}
+
+	scrollUp(): void {
+		this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+	}
+
+	scrollDown(): void {
+		this.scrollOffset++;
+	}
+
+	invalidate(): void {
+		/* stateless */
+	}
+
+	render(width: number, maxLines: number): string[] {
+		const th = this.theme;
+
+		if (!this.taskId) {
+			return this.padToHeight(["", th.fg("muted", "  No task selected")], maxLines);
+		}
+
+		const task = store.loadTask(this.squadId, this.taskId);
+		if (!task) {
+			return this.padToHeight(["", th.fg("error", "  Task not found")], maxLines);
+		}
+
+		const messages = store.loadMessages(this.squadId, this.taskId);
+		const lines: string[] = [];
+
+		// Header: task info
+		const statusColor = task.status === "done" ? "success"
+			: task.status === "failed" ? "error"
+			: task.status === "in_progress" ? "warning"
+			: "muted";
+		lines.push(` ${th.fg("accent", th.bold(task.id))} · ${th.fg("dim", task.agent)} ${th.fg(statusColor as any, task.status)}`);
+		lines.push(` ${th.fg("dim", task.title.slice(0, width - 2))}`);
+		lines.push("");
+
+		if (messages.length === 0) {
+			lines.push(th.fg("muted", "  No messages yet"));
+			return this.padToHeight(lines, maxLines);
+		}
+
+		// Render messages
+		const msgLines = this.renderMessages(messages, width);
+
+		// Apply scroll
+		const contentHeight = maxLines - lines.length - 1;
+		const maxScroll = Math.max(0, msgLines.length - contentHeight);
+		this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
+		// Auto-scroll to bottom if near the end
+		if (this.scrollOffset >= maxScroll - 2) {
+			this.scrollOffset = maxScroll;
+		}
+
+		const visible = msgLines.slice(this.scrollOffset, this.scrollOffset + contentHeight);
+		lines.push(...visible);
+
+		// Scroll indicator
+		if (msgLines.length > contentHeight) {
+			const pos = maxScroll > 0 ? Math.round((this.scrollOffset / maxScroll) * 100) : 100;
+			lines.push(th.fg("dim", ` ─── ${pos}% ───`));
+		}
+
+		return this.padToHeight(lines, maxLines);
+	}
+
+	// =========================================================================
+	// Message Rendering
+	// =========================================================================
+
+	private renderMessages(messages: TaskMessage[], width: number): string[] {
+		const th = this.theme;
+		const lines: string[] = [];
+		let lastFrom: string | null = null;
+
+		for (const msg of messages) {
+			// Skip system status messages that are noise
+			if (msg.type === "status" && msg.from === "system" && msg.text === "Agent starting work") {
+				continue;
+			}
+
+			// Group consecutive messages from the same sender
+			const showHeader = msg.from !== lastFrom;
+			lastFrom = msg.from;
+
+			if (showHeader) {
+				// Blank line between different senders
+				if (lines.length > 0) lines.push("");
+
+				// Sender header with timestamp
+				const time = this.formatTime(msg.ts);
+				const senderColor = this.getSenderColor(msg.from);
+				const senderName = msg.from === "human" ? "YOU" : msg.from;
+				lines.push(` ${th.fg("dim", time)} ${th.fg(senderColor as any, senderName)}`);
+			}
+
+			// Message content
+			switch (msg.type) {
+				case "tool": {
+					const toolName = msg.name || msg.text;
+					const argsStr = msg.args?.path || msg.args?.command || "";
+					const preview = argsStr
+						? `→ ${toolName} ${argsStr}`
+						: `→ ${toolName}`;
+					lines.push(`   ${th.fg("muted", preview.slice(0, width - 4))}`);
+					break;
+				}
+
+				case "mention": {
+					const target = msg.to ? `→ ${msg.to}` : "";
+					lines.push(`   ${th.fg("accent", `@${msg.to || "?"}`)} ${th.fg("dim", msg.text.slice(0, width - 10))}`);
+					break;
+				}
+
+				case "text":
+				case "message":
+				case "reply": {
+					// Wrap long text
+					const textLines = this.wrapText(msg.text, width - 4);
+					for (const textLine of textLines.slice(0, 10)) {
+						lines.push(`   ${textLine}`);
+					}
+					if (textLines.length > 10) {
+						lines.push(`   ${th.fg("dim", `... +${textLines.length - 10} lines`)}`);
+					}
+					break;
+				}
+
+				case "done": {
+					lines.push(`   ${th.fg("success", "✓ " + msg.text.slice(0, width - 6))}`);
+					break;
+				}
+
+				case "error": {
+					lines.push(`   ${th.fg("error", "✗ " + msg.text.slice(0, width - 6))}`);
+					break;
+				}
+
+				case "status": {
+					lines.push(`   ${th.fg("dim", msg.text.slice(0, width - 4))}`);
+					break;
+				}
+			}
+		}
+
+		return lines;
+	}
+
+	// =========================================================================
+	// Helpers
+	// =========================================================================
+
+	private getSenderColor(from: string): string {
+		if (from === "human") return "accent";
+		if (from === "system") return "dim";
+		// Rotate through available colors for different agents
+		const colors = ["success", "warning", "accent", "muted"];
+		let hash = 0;
+		for (const c of from) hash = (hash * 31 + c.charCodeAt(0)) & 0x7fffffff;
+		return colors[hash % colors.length];
+	}
+
+	private formatTime(ts: string): string {
+		try {
+			const d = new Date(ts);
+			const h = d.getHours().toString().padStart(2, "0");
+			const m = d.getMinutes().toString().padStart(2, "0");
+			return `${h}:${m}`;
+		} catch {
+			return "??:??";
+		}
+	}
+
+	private wrapText(text: string, maxWidth: number): string[] {
+		const lines: string[] = [];
+		for (const rawLine of text.split("\n")) {
+			if (rawLine.length <= maxWidth) {
+				lines.push(rawLine);
+			} else {
+				// Simple word wrap
+				let remaining = rawLine;
+				while (remaining.length > maxWidth) {
+					const breakAt = remaining.lastIndexOf(" ", maxWidth);
+					const splitAt = breakAt > maxWidth * 0.3 ? breakAt : maxWidth;
+					lines.push(remaining.slice(0, splitAt));
+					remaining = remaining.slice(splitAt).trimStart();
+				}
+				if (remaining) lines.push(remaining);
+			}
+		}
+		return lines;
+	}
+
+	private padToHeight(lines: string[], maxLines: number): string[] {
+		while (lines.length < maxLines) {
+			lines.push("");
+		}
+		return lines.slice(0, maxLines);
+	}
+}