pi-crew 0.1.49 → 0.2.0

package/src/runtime/live-irc.ts

@@ -1,92 +1,92 @@
-/**
- * Phase 7: Inter-agent communication for live-session workers.
- *
- * Provides IRC-like messaging between live-session workers, adapted from
- * oh-my-pi's IrcTool pattern. Uses the existing LiveAgentHandle manager
- * for message routing.
- *
- * Features:
- * - DM: Send a message to a specific agent
- * - Broadcast: Send a message to all live agents
- * - Side-channel: Non-blocking message injection (via pendingFollowUps)
- *
- * For child-process workers, messages fall back to file-based mailbox.
- */
-
-export type IrcOperation = "send" | "list";
-
-export interface IrcMessage {
-	from: string;
-	to: string;
-	content: string;
-	timestamp: string;
-	/** Whether the sender expects a reply. */
-	awaitReply?: boolean;
-}
-
-export interface IrcSendMessage {
-	op: IrcOperation;
-	/** Target agent ID or "all" for broadcast. */
-	to: string;
-	/** Message content. */
-	message: string;
-	/** Whether to wait for a reply (default: true for DM, false for broadcast). */
-	awaitReply?: boolean;
-}
-
-export interface IrcListResult {
-	peers: Array<{ id: string; name: string; status: string }>;
-}
-
-/**
- * Build IRC peer roster for injection into system prompt.
- * Lists all currently live agents except the caller.
- */
-export function renderIrcPeerRoster(selfId: string, peers: Array<{ agentId: string; status: string }>): string {
-	const visible = peers.filter((p) => p.agentId !== selfId && (p.status === "running" || p.status === "idle"));
-	if (visible.length === 0) return "- (no other live agents)";
-	return visible.map((peer) => `- \`${peer.agentId}\` (${peer.status})`).join("\n");
-}
-
-/**
- * Build the IRC system prompt section for a live-session worker.
- */
-export function buildIrcSystemSection(selfId: string, peers: Array<{ agentId: string; status: string }>): string {
-	const roster = renderIrcPeerRoster(selfId, peers);
-	return [
-		"## Inter-Agent Communication",
-		`Your agent ID: \`${selfId}\``,
-		"You can send messages to other live agents via the `irc` tool.",
-		"Available peers:",
-		roster,
-	].join("\n");
-}
-
-/**
- * Route an IRC message to the appropriate agent(s).
- * Returns the list of agent IDs that received the message.
- */
-export function routeIrcMessage(
-	message: IrcSendMessage,
-	selfId: string,
-	routing: {
-		sendDm: (agentId: string, content: string) => void;
-		broadcast: (content: string, excludeId: string) => string[];
-	},
-): { deliveredTo: string[]; error?: string } {
-	if (!message.to || !message.message?.trim()) {
-		return { deliveredTo: [], error: "Missing 'to' (agent ID or 'all') and 'message' fields." };
-	}
-	if (message.to === selfId) {
-		return { deliveredTo: [], error: "Cannot send a message to yourself." };
-	}
-
-	if (message.to === "all") {
-		const recipients = routing.broadcast(message.message, selfId);
-		return { deliveredTo: recipients };
-	}
-
-	// DM to specific agent
-	routing.sendDm(message.to, message.message);
-	return { deliveredTo: [message.to] };
-}
+/**
+ * Phase 7: Inter-agent communication for live-session workers.
+ *
+ * Provides IRC-like messaging between live-session workers, adapted from
+ * oh-my-pi's IrcTool pattern. Uses the existing LiveAgentHandle manager
+ * for message routing.
+ *
+ * Features:
+ * - DM: Send a message to a specific agent
+ * - Broadcast: Send a message to all live agents
+ * - Side-channel: Non-blocking message injection (via pendingFollowUps)
+ *
+ * For child-process workers, messages fall back to file-based mailbox.
+ */
+
+export type IrcOperation = "send" | "list";
+
+export interface IrcMessage {
+	from: string;
+	to: string;
+	content: string;
+	timestamp: string;
+	/** Whether the sender expects a reply. */
+	awaitReply?: boolean;
+}
+
+export interface IrcSendMessage {
+	op: IrcOperation;
+	/** Target agent ID or "all" for broadcast. */
+	to: string;
+	/** Message content. */
+	message: string;
+	/** Whether to wait for a reply (default: true for DM, false for broadcast). */
+	awaitReply?: boolean;
+}
+
+export interface IrcListResult {
+	peers: Array<{ id: string; name: string; status: string }>;
+}
+
+/**
+ * Build IRC peer roster for injection into system prompt.
+ * Lists all currently live agents except the caller.
+ */
+export function renderIrcPeerRoster(selfId: string, peers: Array<{ agentId: string; status: string }>): string {
+	const visible = peers.filter((p) => p.agentId !== selfId && (p.status === "running" || p.status === "idle"));
+	if (visible.length === 0) return "- (no other live agents)";
+	return visible.map((peer) => `- \`${peer.agentId}\` (${peer.status})`).join("\n");
+}
+
+/**
+ * Build the IRC system prompt section for a live-session worker.
+ */
+export function buildIrcSystemSection(selfId: string, peers: Array<{ agentId: string; status: string }>): string {
+	const roster = renderIrcPeerRoster(selfId, peers);
+	return [
+		"## Inter-Agent Communication",
+		`Your agent ID: \`${selfId}\``,
+		"You can send messages to other live agents via the `irc` tool.",
+		"Available peers:",
+		roster,
+	].join("\n");
+}
+
+/**
+ * Route an IRC message to the appropriate agent(s).
+ * Returns the list of agent IDs that received the message.
+ */
+export function routeIrcMessage(
+	message: IrcSendMessage,
+	selfId: string,
+	routing: {
+		sendDm: (agentId: string, content: string) => void;
+		broadcast: (content: string, excludeId: string) => string[];
+	},
+): { deliveredTo: string[]; error?: string } {
+	if (!message.to || !message.message?.trim()) {
+		return { deliveredTo: [], error: "Missing 'to' (agent ID or 'all') and 'message' fields." };
+	}
+	if (message.to === selfId) {
+		return { deliveredTo: [], error: "Cannot send a message to yourself." };
+	}
+
+	if (message.to === "all") {
+		const recipients = routing.broadcast(message.message, selfId);
+		return { deliveredTo: recipients };
+	}
+
+	// DM to specific agent
+	routing.sendDm(message.to, message.message);
+	return { deliveredTo: [message.to] };
+}

package/src/runtime/live-session-health.ts

@@ -1,100 +1,100 @@
-/**
- * Phase 8: Monitoring and observability for live-session workers.
- *
- * Provides health checks, metrics collection, and diagnostics
- * for live-session workers running in-process.
- */
-
-export interface LiveSessionHealth {
-	/** Total number of registered live agents. */
-	totalAgents: number;
-	/** Number of agents currently running. */
-	runningAgents: number;
-	/** Number of agents in idle state. */
-	idleAgents: number;
-	/** Number of agents that have completed. */
-	completedAgents: number;
-	/** Number of agents that have failed. */
-	failedAgents: number;
-	/** Total tokens consumed across all live sessions. */
-	totalTokens: number;
-	/** Timestamp of this health snapshot. */
-	timestamp: string;
-}
-
-export interface LiveSessionMetrics {
-	agentId: string;
-	taskId: string;
-	status: string;
-	/** Accumulated usage from session stats. */
-	usage?: {
-		input?: number;
-		output?: number;
-		cacheRead?: number;
-		cacheWrite?: number;
-		cost?: number;
-		turns?: number;
-	};
-	/** Session duration in milliseconds. */
-	durationMs?: number;
-	/** Number of IRC messages received. */
-	ircMessagesReceived?: number;
-	/** Number of yield reminders sent. */
-	yieldReminders?: number;
-	/** Whether yield was called. */
-	yieldCalled: boolean;
-}
-
-/**
- * Collect health snapshot from live agent handles.
- */
-export function collectLiveSessionHealth(
-	agents: Array<{ status: string }>,
-	getUsage: (agentId: string) => { input?: number; output?: number; turns?: number } | undefined,
-): LiveSessionHealth {
-	let running = 0;
-	let idle = 0;
-	let completed = 0;
-	let failed = 0;
-	let totalTokens = 0;
-
-	for (const agent of agents) {
-		switch (agent.status) {
-			case "running": running++; break;
-			case "idle": idle++; break;
-			case "completed": completed++; break;
-			case "failed": failed++; break;
-		}
-	}
-
-	// Sum tokens from usage data
-	for (const agent of agents) {
-		const agentAny = agent as Record<string, unknown>;
-		const agentId = agentAny.agentId as string | undefined;
-		if (agentId) {
-			const usage = getUsage(agentId);
-			if (usage) {
-				totalTokens += (usage.input ?? 0) + (usage.output ?? 0);
-			}
-		}
-	}
-
-	return {
-		totalAgents: agents.length,
-		runningAgents: running,
-		idleAgents: idle,
-		completedAgents: completed,
-		failedAgents: failed,
-		totalTokens,
-		timestamp: new Date().toISOString(),
-	};
-}
-
-/**
- * Build a diagnostic summary string for logging.
- */
-export function formatLiveSessionDiagnostics(health: LiveSessionHealth): string {
-	return [
-		`[Live-Session Health] agents=${health.totalAgents} running=${health.runningAgents} idle=${health.idleAgents} completed=${health.completedAgents} failed=${health.failedAgents} tokens=${health.totalTokens}`,
-	].join("\n");
-}
+/**
+ * Phase 8: Monitoring and observability for live-session workers.
+ *
+ * Provides health checks, metrics collection, and diagnostics
+ * for live-session workers running in-process.
+ */
+
+export interface LiveSessionHealth {
+	/** Total number of registered live agents. */
+	totalAgents: number;
+	/** Number of agents currently running. */
+	runningAgents: number;
+	/** Number of agents in idle state. */
+	idleAgents: number;
+	/** Number of agents that have completed. */
+	completedAgents: number;
+	/** Number of agents that have failed. */
+	failedAgents: number;
+	/** Total tokens consumed across all live sessions. */
+	totalTokens: number;
+	/** Timestamp of this health snapshot. */
+	timestamp: string;
+}
+
+export interface LiveSessionMetrics {
+	agentId: string;
+	taskId: string;
+	status: string;
+	/** Accumulated usage from session stats. */
+	usage?: {
+		input?: number;
+		output?: number;
+		cacheRead?: number;
+		cacheWrite?: number;
+		cost?: number;
+		turns?: number;
+	};
+	/** Session duration in milliseconds. */
+	durationMs?: number;
+	/** Number of IRC messages received. */
+	ircMessagesReceived?: number;
+	/** Number of yield reminders sent. */
+	yieldReminders?: number;
+	/** Whether yield was called. */
+	yieldCalled: boolean;
+}
+
+/**
+ * Collect health snapshot from live agent handles.
+ */
+export function collectLiveSessionHealth(
+	agents: Array<{ status: string }>,
+	getUsage: (agentId: string) => { input?: number; output?: number; turns?: number } | undefined,
+): LiveSessionHealth {
+	let running = 0;
+	let idle = 0;
+	let completed = 0;
+	let failed = 0;
+	let totalTokens = 0;
+
+	for (const agent of agents) {
+		switch (agent.status) {
+			case "running": running++; break;
+			case "idle": idle++; break;
+			case "completed": completed++; break;
+			case "failed": failed++; break;
+		}
+	}
+
+	// Sum tokens from usage data
+	for (const agent of agents) {
+		const agentAny = agent as Record<string, unknown>;
+		const agentId = agentAny.agentId as string | undefined;
+		if (agentId) {
+			const usage = getUsage(agentId);
+			if (usage) {
+				totalTokens += (usage.input ?? 0) + (usage.output ?? 0);
+			}
+		}
+	}
+
+	return {
+		totalAgents: agents.length,
+		runningAgents: running,
+		idleAgents: idle,
+		completedAgents: completed,
+		failedAgents: failed,
+		totalTokens,
+		timestamp: new Date().toISOString(),
+	};
+}
+
+/**
+ * Build a diagnostic summary string for logging.
+ */
+export function formatLiveSessionDiagnostics(health: LiveSessionHealth): string {
+	return [
+		`[Live-Session Health] agents=${health.totalAgents} running=${health.runningAgents} idle=${health.idleAgents} completed=${health.completedAgents} failed=${health.failedAgents} tokens=${health.totalTokens}`,
+	].join("\n");
+}

package/src/runtime/loop-gates.ts

@@ -0,0 +1,129 @@
+/**
+ * Dual-gate loop control — determines whether a task should auto-resume
+ * based on meaningful progress and turn limits.
+ *
+ * Gate 1: At least one signal of meaningful progress must be true.
+ * Gate 2: The auto-resume turn count must be below the maximum.
+ *
+ * Distilled from pi-autoresearch's dual-gate loop pattern.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { TeamTaskState } from "../state/types.ts";
+
+/**
+ * Signal indicating what kind of progress a task has made.
+ */
+export interface TaskProgressSignal {
+	/** Whether the task has edited files or produced non-empty results. */
+	editedFiles: boolean;
+	/** Whether the task has produced artifacts in the artifacts directory. */
+	producedArtifacts: boolean;
+	/** Whether the task has run tests (detected via result text). */
+	ranTests: boolean;
+}
+
+/**
+ * Runtime state for auto-resume turn tracking.
+ */
+export interface AutoResumeRuntime {
+	/** Current number of auto-resume turns taken. */
+	autoResumeTurns: number;
+	/** Maximum allowed auto-resume turns. */
+	maxTurns: number;
+}
+
+/** Keywords in result text that indicate tests were run. */
+const TEST_KEYWORDS = [
+	"test passed",
+	"test failed",
+	"tests passed",
+	"tests failed",
+	"test results",
+	"jest",
+	"vitest",
+	"mocha",
+	"pytest",
+	"npx test",
+	"npm test",
+	"cargo test",
+	"all tests",
+	"test suite",
+	"✓",
+	"✗",
+	"PASS ",
+	" FAIL ",
+] as const;
+
+/**
+ * Determine whether a task should auto-resume based on dual-gate logic.
+ *
+ * Gate 1 (meaningful progress): at least one of editedFiles, producedArtifacts,
+ *   or ranTests must be true.
+ * Gate 2 (turn limit): autoResumeTurns must be strictly less than maxTurns.
+ *
+ * Both gates must pass for auto-resume to be allowed.
+ */
+export function shouldAutoResume(runtime: AutoResumeRuntime, taskProgress: TaskProgressSignal): boolean {
+	// Gate 2: Turn limit check (check first — cheaper)
+	if (runtime.autoResumeTurns >= runtime.maxTurns) {
+		return false;
+	}
+
+	// Gate 1: Meaningful progress check
+	const hasProgress = taskProgress.editedFiles || taskProgress.producedArtifacts || taskProgress.ranTests;
+	if (!hasProgress) {
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Compute the task progress signal from a task's state and artifacts directory.
+ *
+ * - editedFiles: true if task has artifact files or a non-empty result
+ * - producedArtifacts: true if artifacts directory contains task-specific files
+ * - ranTests: true if result text contains test-related keywords
+ *
+ * @param task - The task state to analyze
+ * @param artifactsDir - Path to the artifacts directory
+ * @returns TaskProgressSignal indicating what progress was made
+ */
+export function computeTaskProgressSignal(task: TeamTaskState, artifactsDir: string): TaskProgressSignal {
+	// editedFiles: check if task has artifact descriptors or a non-empty result
+	const hasResultArtifact = task.resultArtifact !== undefined;
+	const hasNonEmptyResult = task.resultArtifact?.path !== undefined;
+	const editedFiles = hasResultArtifact || hasNonEmptyResult;
+
+	// producedArtifacts: check artifacts directory for task-specific files
+	let producedArtifacts = false;
+	if (artifactsDir && fs.existsSync(artifactsDir)) {
+		try {
+			const entries = fs.readdirSync(artifactsDir);
+			// Look for files/directories that START with the task ID prefix.
+			// Using startsWith instead of includes to avoid false positives
+			// from short task IDs like "01" matching unrelated entries.
+			const taskPrefix = task.id.replace(/[^a-zA-Z0-9_-]/g, "");
+			producedArtifacts = entries.some((entry) => {
+				const baseName = entry.split(".")[0] ?? entry;
+				return baseName.startsWith(taskPrefix);
+			});
+		} catch {
+			producedArtifacts = false;
+		}
+	}
+
+	// ranTests: check if result-related fields contain test keywords
+	let ranTests = false;
+	const textToSearch = [
+		task.error ?? "",
+		task.terminalEvidence ? JSON.stringify(task.terminalEvidence) : "",
+		task.diagnostics ? JSON.stringify(task.diagnostics) : "",
+	].join(" ");
+
+	const lowerText = textToSearch.toLowerCase();
+	ranTests = TEST_KEYWORDS.some((keyword) => lowerText.includes(keyword.toLowerCase()));
+
+	return { editedFiles, producedArtifacts, ranTests };
+}

package/src/runtime/metric-parser.ts

@@ -0,0 +1,40 @@
+/**
+ * Metric names that are denied to prevent prototype pollution.
+ */
+export const DENIED_METRIC_NAMES: ReadonlySet<string> = new Set([
+	"__proto__",
+	"constructor",
+	"prototype",
+]);
+
+const METRIC_LINE_RE = /^CREW_METRIC\s+(\w+)=(\S+)$/;
+
+/**
+ * Parse CREW_METRIC lines from worker stdout.
+ *
+ * Lines must match the pattern: `CREW_METRIC name=value`
+ * - `name` must be a word character sequence (alphanumeric + underscore)
+ * - `value` must parse as a valid finite number
+ * - Denied names (__proto__, constructor, prototype) are silently skipped
+ *
+ * @param output - Raw worker stdout text
+ * @returns Map of metric name → numeric value
+ */
+export function parseMetricLines(output: string): Record<string, number> {
+	const metrics: Record<string, number> = {};
+
+	for (const line of output.split("\n")) {
+		const match = METRIC_LINE_RE.exec(line);
+		if (!match) continue;
+
+		const [, name, rawValue] = match;
+		if (DENIED_METRIC_NAMES.has(name)) continue;
+
+		const value = Number(rawValue);
+		if (!Number.isFinite(value)) continue;
+
+		metrics[name] = value;
+	}
+
+	return metrics;
+}