@pantheon.ai/agents 0.0.11 → 0.0.12

package/dist/index.js

@@ -13,6 +13,8 @@ import expandTilde from "expand-tilde";
 import express, { Router } from "express";
 import { randomUUID } from "node:crypto";
 import { URL as URL$1 } from "node:url";
+import blessed from "reblessed";
+import { inspect } from "node:util";
 
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -420,7 +422,7 @@ var require_cli_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 
 //#endregion
 //#region package.json
-var version$1 = "0.0.11";
+var version$1 = "0.0.12";
 
 //#endregion
 //#region src/schemas/task-list.ts
@@ -9611,6 +9613,12 @@ async function getPantheonBranch({ projectId, branchId, getOutputIfFinished = fa
 	}
 	return { state: "others" };
 }
+async function getPantheonBranchInfo({ projectId, branchId }) {
+	return await executor.execute(getProjectBranch, {
+		projectId,
+		branchId
+	}, null);
+}
 async function executeOnPantheon({ projectId, branchId, prompt, agent }) {
 	return (await executor.execute(createProjectExploration, { projectId }, {
 		shared_prompt_sequence: [prompt],
@@ -9706,6 +9714,327 @@ async function startPendingTask(provider, task, logger) {
 	logger.info(`Task ${task.id} started successfully.`);
 }
 
+//#endregion
+//#region src/core/watch/selector.ts
+const finishedTaskStatuses = [
+	"completed",
+	"failed",
+	"cancelled"
+];
+function isFinishedTaskStatus(status) {
+	return finishedTaskStatuses.includes(status);
+}
+function getTaskTimestampMs(task) {
+	switch (task.status) {
+		case "running": return task.started_at.getTime();
+		case "completed": return task.ended_at.getTime();
+		case "failed": return task.ended_at?.getTime() ?? task.started_at?.getTime() ?? 0;
+		case "cancelled": return task.cancelled_at.getTime();
+		case "pending": return task.queued_at.getTime();
+	}
+}
+function pickLatestRunningTask(tasks) {
+	const running = tasks.filter((task) => task.status === "running");
+	running.sort((a, b) => getTaskTimestampMs(b) - getTaskTimestampMs(a));
+	return running[0];
+}
+function pickLatestFinishedTasks(tasks, limit) {
+	const finished = tasks.filter((task) => isFinishedTaskStatus(task.status));
+	finished.sort((a, b) => getTaskTimestampMs(b) - getTaskTimestampMs(a));
+	return finished.slice(0, limit);
+}
+function selectSingleAgentWatchTasks(tasks, options = {}) {
+	const finishedLimit = options.finishedLimit ?? 3;
+	const out = [];
+	const running = pickLatestRunningTask(tasks);
+	if (running) out.push(running);
+	const finished = pickLatestFinishedTasks(tasks, finishedLimit);
+	out.push(...finished);
+	return out;
+}
+function selectMultiAgentWatchTasks(tasks, agentNames) {
+	const out = [];
+	for (const agent of agentNames) {
+		const agentTasks = tasks.filter((entry) => entry.agent === agent).map((entry) => entry.task);
+		const running = pickLatestRunningTask(agentTasks);
+		if (running) {
+			out.push({
+				agent,
+				task: running
+			});
+			continue;
+		}
+		const latestFinished = pickLatestFinishedTasks(agentTasks, 1)[0];
+		if (latestFinished) out.push({
+			agent,
+			task: latestFinished
+		});
+	}
+	return out;
+}
+function selectFallbackWatchTasks(tasks, options = {}) {
+	const agentLimit = options.agentLimit ?? 3;
+	const byAgent = /* @__PURE__ */ new Map();
+	for (const entry of tasks) {
+		const existing = byAgent.get(entry.agent);
+		if (existing) existing.push(entry.task);
+		else byAgent.set(entry.agent, [entry.task]);
+	}
+	const runningCandidates = [];
+	const finishedCandidates = [];
+	for (const [agent, agentTasks] of byAgent) {
+		const running = pickLatestRunningTask(agentTasks);
+		if (running) {
+			runningCandidates.push({
+				agent,
+				task: running
+			});
+			continue;
+		}
+		const latestFinished = pickLatestFinishedTasks(agentTasks, 1)[0];
+		if (latestFinished) finishedCandidates.push({
+			agent,
+			task: latestFinished
+		});
+	}
+	runningCandidates.sort((a, b) => getTaskTimestampMs(b.task) - getTaskTimestampMs(a.task));
+	finishedCandidates.sort((a, b) => getTaskTimestampMs(b.task) - getTaskTimestampMs(a.task));
+	const selected = [];
+	const selectedAgents = /* @__PURE__ */ new Set();
+	for (const entry of [...runningCandidates, ...finishedCandidates]) {
+		if (selected.length >= agentLimit) break;
+		if (selectedAgents.has(entry.agent)) continue;
+		selectedAgents.add(entry.agent);
+		selected.push(entry);
+	}
+	return selected;
+}
+
+//#endregion
+//#region src/core/watch/stream.ts
+async function consumeOpaqueSseStream(options) {
+	const reader = options.stream.getReader();
+	let ended = false;
+	let abortedByIdleTimeout = false;
+	let buffer = "";
+	let idleTimer;
+	function warn(message) {
+		options.onWarning?.(message);
+	}
+	function cancelReader(reason) {
+		try {
+			reader.cancel(reason);
+		} catch {}
+	}
+	function resetIdleTimer() {
+		if (options.idleTimeoutMs == null) return;
+		clearTimeout(idleTimer);
+		idleTimer = setTimeout(() => {
+			abortedByIdleTimeout = true;
+			cancelReader("idle_timeout");
+		}, options.idleTimeoutMs);
+	}
+	resetIdleTimer();
+	function processEventBlock(block) {
+		const lines = block.split("\n");
+		for (const rawLine of lines) {
+			const line = rawLine.trimEnd();
+			if (!line.startsWith("data:")) continue;
+			const part = line.slice(5).trimStart();
+			if (!part || part === "[DONE]") continue;
+			try {
+				options.onData(part);
+				resetIdleTimer();
+			} catch (error) {
+				warn(`onData handler threw; skipping chunk. ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+	const textDecoder = new TextDecoder();
+	try {
+		while (true) {
+			if (options.signal?.aborted) {
+				cancelReader("aborted");
+				break;
+			}
+			const { value, done } = await reader.read();
+			if (done) {
+				ended = !abortedByIdleTimeout;
+				break;
+			}
+			const decoded = textDecoder.decode(value, { stream: true });
+			buffer += decoded.replaceAll("\r\n", "\n");
+			while (true) {
+				const sepIndex = buffer.indexOf("\n\n");
+				if (sepIndex === -1) break;
+				const block = buffer.slice(0, sepIndex);
+				buffer = buffer.slice(sepIndex + 2);
+				if (block.trim()) processEventBlock(block);
+			}
+		}
+	} finally {
+		clearTimeout(idleTimer);
+	}
+	if (buffer.trim()) warn("Stream ended with trailing incomplete SSE data; ignoring remaining buffer.");
+	return {
+		ended,
+		abortedByIdleTimeout
+	};
+}
+var WatchStepAggregator = class {
+	maxLeadingTextChars;
+	maxLeadingReasoningChars;
+	maxLogLines;
+	maxWarnings;
+	leadingText = "";
+	leadingReasoning = "";
+	toolActions = /* @__PURE__ */ new Map();
+	logLines = [];
+	warnings = [];
+	unknownEventCount = 0;
+	orderCounter = 0;
+	constructor(options = {}) {
+		this.maxLeadingTextChars = options.maxLeadingTextChars ?? 800;
+		this.maxLeadingReasoningChars = options.maxLeadingReasoningChars ?? 800;
+		this.maxLogLines = options.maxLogLines ?? 200;
+		this.maxWarnings = options.maxWarnings ?? 50;
+	}
+	pushLog(line) {
+		if (!line) return;
+		this.logLines.push(line);
+		if (this.logLines.length > this.maxLogLines) this.logLines.splice(0, this.logLines.length - this.maxLogLines);
+	}
+	pushWarning(message) {
+		if (!message) return;
+		this.warnings.push(message);
+		if (this.warnings.length > this.maxWarnings) this.warnings.splice(0, this.warnings.length - this.maxWarnings);
+	}
+	pushCommandExecutionOutput(output) {
+		const out = output;
+		const aggregated = typeof out?.aggregated_output === "string" ? out.aggregated_output : "";
+		const exitCode = typeof out?.exit_code === "number" ? out.exit_code : void 0;
+		const trimmed = aggregated.replaceAll("\r\n", "\n").trimEnd();
+		if (trimmed) trimmed.split("\n").forEach((line) => this.pushLog(line));
+		if (exitCode != null && exitCode !== 0) this.pushLog(`exit_code=${exitCode}`);
+	}
+	getOrCreateToolAction(toolCallId) {
+		const existing = this.toolActions.get(toolCallId);
+		if (existing) return existing;
+		const created = {
+			toolCallId,
+			status: "in_progress",
+			_order: this.orderCounter++
+		};
+		this.toolActions.set(toolCallId, created);
+		return created;
+	}
+	pushUiChunk(chunk) {
+		if (typeof chunk !== "object" || chunk === null) return;
+		const type = chunk.type;
+		if (typeof type !== "string") return;
+		switch (type) {
+			case "text-delta": {
+				const delta = typeof chunk.delta === "string" ? chunk.delta : "";
+				if (!delta) return;
+				if (this.leadingText.length < this.maxLeadingTextChars) {
+					const remaining = this.maxLeadingTextChars - this.leadingText.length;
+					this.leadingText += delta.slice(0, remaining);
+				}
+				return;
+			}
+			case "reasoning-delta": {
+				const delta = typeof chunk.delta === "string" ? chunk.delta : "";
+				if (!delta) return;
+				if (this.leadingReasoning.length < this.maxLeadingReasoningChars) {
+					const remaining = this.maxLeadingReasoningChars - this.leadingReasoning.length;
+					this.leadingReasoning += delta.slice(0, remaining);
+				}
+				return;
+			}
+			case "tool-input-start": {
+				const toolCallId = typeof chunk.toolCallId === "string" ? chunk.toolCallId : "";
+				if (!toolCallId) return;
+				const toolName = typeof chunk.toolName === "string" ? chunk.toolName : void 0;
+				const toolAction = this.getOrCreateToolAction(toolCallId);
+				toolAction.toolName = toolName ?? toolAction.toolName;
+				toolAction.status = "in_progress";
+				if (toolAction.toolName !== "command_execution") this.pushLog(`→ tool ${toolAction.toolName ?? "<tool>"} (${toolCallId})`);
+				return;
+			}
+			case "tool-input-delta": {
+				const toolCallId = typeof chunk.toolCallId === "string" ? chunk.toolCallId : "";
+				if (!toolCallId) return;
+				const toolAction = this.getOrCreateToolAction(toolCallId);
+				toolAction.status = "in_progress";
+				return;
+			}
+			case "tool-input-available": {
+				const toolCallId = typeof chunk.toolCallId === "string" ? chunk.toolCallId : "";
+				if (!toolCallId) return;
+				const toolName = typeof chunk.toolName === "string" ? chunk.toolName : void 0;
+				const title = typeof chunk.title === "string" ? chunk.title : void 0;
+				const input = chunk.input;
+				const toolAction = this.getOrCreateToolAction(toolCallId);
+				toolAction.toolName = toolName ?? toolAction.toolName;
+				toolAction.title = title ?? toolAction.title;
+				toolAction.input = input ?? toolAction.input;
+				toolAction.status = "in_progress";
+				const toolLabel = toolAction.title ? `${toolAction.toolName ?? "<tool>"}: ${toolAction.title}` : `${toolAction.toolName ?? "<tool>"}`;
+				if (toolAction.toolName !== "command_execution") this.pushLog(`→ tool ${toolLabel} (${toolCallId})`);
+				return;
+			}
+			case "tool-output-available": {
+				const toolCallId = typeof chunk.toolCallId === "string" ? chunk.toolCallId : "";
+				if (!toolCallId) return;
+				const output = chunk.output;
+				const toolAction = this.getOrCreateToolAction(toolCallId);
+				toolAction.output = output;
+				toolAction.status = "completed";
+				if (toolAction.toolName === "command_execution") {
+					this.pushCommandExecutionOutput(output);
+					return;
+				}
+				this.pushLog(`← tool ${toolAction.toolName ?? "<tool>"} ok (${toolCallId})`);
+				return;
+			}
+			case "tool-output-error":
+			case "tool-input-error": {
+				const toolCallId = typeof chunk.toolCallId === "string" ? chunk.toolCallId : "";
+				if (!toolCallId) return;
+				const errorText = typeof chunk.errorText === "string" ? chunk.errorText : "";
+				const toolAction = this.getOrCreateToolAction(toolCallId);
+				toolAction.errorText = errorText || toolAction.errorText;
+				toolAction.status = "failed";
+				this.pushLog(`← tool ${toolAction.toolName ?? "<tool>"} error (${toolCallId})`);
+				return;
+			}
+			case "data-agent-unknown": {
+				this.unknownEventCount++;
+				const data = chunk.data;
+				const reason = typeof data?.reason === "string" ? data.reason : "unknown chunk";
+				this.pushWarning(reason);
+				this.pushLog(`! unknown: ${reason}`);
+				return;
+			}
+			default: return;
+		}
+	}
+	pushUiChunks(chunks) {
+		chunks.forEach((chunk) => this.pushUiChunk(chunk));
+	}
+	snapshot() {
+		const actions = Array.from(this.toolActions.values()).sort((a, b) => a._order - b._order).map(({ _order: _unused, ...rest }) => rest);
+		return {
+			leadingText: this.leadingText,
+			leadingReasoning: this.leadingReasoning,
+			toolActions: actions,
+			logLines: [...this.logLines],
+			warnings: [...this.warnings],
+			unknownEventCount: this.unknownEventCount
+		};
+	}
+};
+
 //#endregion
 //#region src/core/index.ts
 function normalizeSkills(value) {
@@ -32245,9 +32574,1607 @@ function createShowTasksCommand(version) {
 	});
 }
 
+//#endregion
+//#region ../agent-stream-parser/src/utils.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function safeJsonParse(text) {
+	try {
+		return {
+			ok: true,
+			value: JSON.parse(text)
+		};
+	} catch (error) {
+		const sanitized = sanitizeMalformedJsonLine(text);
+		if (sanitized !== text) try {
+			return {
+				ok: true,
+				value: JSON.parse(sanitized)
+			};
+		} catch {}
+		return {
+			ok: false,
+			error
+		};
+	}
+}
+function sanitizeMalformedJsonLine(text) {
+	return text.replaceAll("", "'").replaceAll("", "—").replaceAll("", "—").replaceAll(/[\u0000-\u001F]/g, "");
+}
+function toErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+function computeAppendDelta(previous, next) {
+	if (next.startsWith(previous)) return {
+		delta: next.slice(previous.length),
+		reset: false
+	};
+	return {
+		delta: next,
+		reset: true
+	};
+}
+
+//#endregion
+//#region ../agent-stream-parser/src/codex.ts
+const usageSchema = z$1.object({
+	input_tokens: z$1.number(),
+	cached_input_tokens: z$1.number(),
+	output_tokens: z$1.number()
+});
+const agentMessageItemSchema = z$1.object({
+	id: z$1.string(),
+	type: z$1.literal("agent_message"),
+	text: z$1.string()
+});
+const reasoningItemSchema = z$1.object({
+	id: z$1.string(),
+	type: z$1.literal("reasoning"),
+	text: z$1.string()
+});
+const commandExecutionItemSchema = z$1.object({
+	id: z$1.string(),
+	type: z$1.literal("command_execution"),
+	command: z$1.string(),
+	aggregated_output: z$1.string(),
+	exit_code: z$1.preprocess((value) => value === null ? void 0 : value, z$1.number().optional()),
+	status: z$1.enum([
+		"in_progress",
+		"completed",
+		"failed"
+	])
+});
+const mcpToolCallItemSchema = z$1.object({
+	id: z$1.string(),
+	type: z$1.literal("mcp_tool_call"),
+	server: z$1.string(),
+	tool: z$1.string(),
+	arguments: z$1.any(),
+	result: z$1.object({
+		content: z$1.array(z$1.any()),
+		structured_content: z$1.any()
+	}).optional(),
+	error: z$1.object({ message: z$1.string() }).optional(),
+	status: z$1.enum([
+		"in_progress",
+		"completed",
+		"failed"
+	])
+});
+const fileChangeItemSchema = z$1.object({
+	id: z$1.string(),
+	type: z$1.literal("file_change"),
+	changes: z$1.array(z$1.object({
+		path: z$1.string(),
+		kind: z$1.enum([
+			"add",
+			"delete",
+			"update"
+		])
+	})),
+	status: z$1.enum(["completed", "failed"])
+});
+const webSearchItemSchema = z$1.object({
+	id: z$1.string(),
+	type: z$1.literal("web_search"),
+	query: z$1.string()
+});
+const todoListItemSchema = z$1.object({
+	id: z$1.string(),
+	type: z$1.literal("todo_list"),
+	items: z$1.array(z$1.object({
+		text: z$1.string(),
+		completed: z$1.boolean()
+	}))
+});
+const errorItemSchema = z$1.object({
+	id: z$1.string(),
+	type: z$1.literal("error"),
+	message: z$1.string()
+});
+const threadItemSchema = z$1.discriminatedUnion("type", [
+	agentMessageItemSchema,
+	reasoningItemSchema,
+	commandExecutionItemSchema,
+	mcpToolCallItemSchema,
+	fileChangeItemSchema,
+	webSearchItemSchema,
+	todoListItemSchema,
+	errorItemSchema
+]);
+const threadEventSchema = z$1.discriminatedUnion("type", [
+	z$1.object({
+		type: z$1.literal("thread.started"),
+		thread_id: z$1.string()
+	}),
+	z$1.object({ type: z$1.literal("turn.started") }),
+	z$1.object({
+		type: z$1.literal("turn.completed"),
+		usage: usageSchema
+	}),
+	z$1.object({
+		type: z$1.literal("turn.failed"),
+		error: z$1.object({ message: z$1.string() })
+	}),
+	z$1.object({
+		type: z$1.literal("item.started"),
+		item: threadItemSchema
+	}),
+	z$1.object({
+		type: z$1.literal("item.updated"),
+		item: threadItemSchema
+	}),
+	z$1.object({
+		type: z$1.literal("item.completed"),
+		item: threadItemSchema
+	}),
+	z$1.object({
+		type: z$1.literal("error"),
+		message: z$1.string()
+	})
+]);
+function createCodexNormalizer(options = {}) {
+	const includeMetaEvents = options.includeMetaEvents ?? false;
+	const activeText = /* @__PURE__ */ new Map();
+	const activeReasoning = /* @__PURE__ */ new Map();
+	function maybeMetaEvent(event) {
+		if (!includeMetaEvents) return [];
+		return [{
+			type: "data-agent-event",
+			data: event
+		}];
+	}
+	function handleTextLike({ map, id, fullText, eventType, startType, deltaType, endType }) {
+		const out = [];
+		let state = map.get(id);
+		if (!state || !state.open) {
+			state = {
+				lastText: "",
+				open: true
+			};
+			map.set(id, state);
+			out.push({
+				type: startType,
+				id
+			});
+		}
+		const { delta, reset } = computeAppendDelta(state.lastText, fullText);
+		if (delta) {
+			out.push({
+				type: deltaType,
+				id,
+				delta
+			});
+			state.lastText = reset ? fullText : state.lastText + delta;
+		}
+		if (eventType === "item.completed") {
+			out.push({
+				type: endType,
+				id
+			});
+			state.open = false;
+		}
+		return out;
+	}
+	function normalizeItemEvent(eventType, item) {
+		const out = [];
+		switch (item.type) {
+			case "agent_message": return {
+				recognized: true,
+				chunks: handleTextLike({
+					map: activeText,
+					id: item.id,
+					fullText: item.text,
+					eventType,
+					startType: "text-start",
+					deltaType: "text-delta",
+					endType: "text-end"
+				})
+			};
+			case "reasoning": return {
+				recognized: true,
+				chunks: handleTextLike({
+					map: activeReasoning,
+					id: item.id,
+					fullText: item.text,
+					eventType,
+					startType: "reasoning-start",
+					deltaType: "reasoning-delta",
+					endType: "reasoning-end"
+				})
+			};
+			case "command_execution": {
+				const toolCallId = item.id;
+				out.push({
+					type: "tool-input-available",
+					toolCallId,
+					toolName: "command_execution",
+					title: item.command,
+					input: { command: item.command },
+					dynamic: true
+				});
+				if (item.status === "completed") out.push({
+					type: "tool-output-available",
+					toolCallId,
+					output: {
+						exit_code: item.exit_code ?? null,
+						aggregated_output: item.aggregated_output
+					},
+					dynamic: true
+				});
+				else if (item.status === "failed") {
+					const exitCode = item.exit_code;
+					out.push({
+						type: "tool-output-error",
+						toolCallId,
+						errorText: exitCode != null ? `Command failed (exit_code=${exitCode}).\n${item.aggregated_output}` : `Command failed.\n${item.aggregated_output}`,
+						dynamic: true
+					});
+				}
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "mcp_tool_call": {
+				const toolCallId = item.id;
+				out.push({
+					type: "tool-input-available",
+					toolCallId,
+					toolName: "mcp_tool_call",
+					title: `${item.server}.${item.tool}`,
+					input: item.arguments,
+					dynamic: true
+				});
+				if (item.status === "completed") out.push({
+					type: "tool-output-available",
+					toolCallId,
+					output: item.result?.structured_content ?? null,
+					dynamic: true
+				});
+				else if (item.status === "failed") out.push({
+					type: "tool-output-error",
+					toolCallId,
+					errorText: item.error?.message ?? "MCP tool call failed",
+					dynamic: true
+				});
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "file_change": {
+				const toolCallId = item.id;
+				out.push({
+					type: "tool-input-available",
+					toolCallId,
+					toolName: "file_change",
+					input: { changes: item.changes },
+					dynamic: true
+				});
+				if (item.status === "completed") out.push({
+					type: "tool-output-available",
+					toolCallId,
+					output: { status: "completed" },
+					dynamic: true
+				});
+				else out.push({
+					type: "tool-output-error",
+					toolCallId,
+					errorText: "Patch apply failed",
+					dynamic: true
+				});
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "web_search": {
+				const toolCallId = item.id;
+				out.push({
+					type: "tool-input-available",
+					toolCallId,
+					toolName: "web_search",
+					title: item.query,
+					input: { query: item.query },
+					dynamic: true
+				});
+				if (eventType === "item.completed") out.push({
+					type: "tool-output-available",
+					toolCallId,
+					output: null,
+					dynamic: true
+				});
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "todo_list": return {
+				recognized: true,
+				chunks: maybeMetaEvent({
+					kind: "codex.todo_list",
+					items: item.items
+				})
+			};
+			case "error":
+				out.push({
+					type: "error",
+					errorText: item.message
+				});
+				out.push(...maybeMetaEvent({
+					kind: "codex.error",
+					message: item.message
+				}));
+				return {
+					recognized: true,
+					chunks: out
+				};
+			default: return {
+				recognized: false,
+				chunks: []
+			};
+		}
+	}
+	function push(chunk) {
+		const parsed = threadEventSchema.safeParse(chunk);
+		if (!parsed.success) return {
+			recognized: false,
+			chunks: []
+		};
+		const event = parsed.data;
+		switch (event.type) {
+			case "thread.started": {
+				const out = [{
+					type: "message-metadata",
+					messageMetadata: {
+						threadId: event.thread_id,
+						source: "codex"
+					}
+				}];
+				out.push(...maybeMetaEvent({
+					kind: "codex.thread.started",
+					threadId: event.thread_id
+				}));
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "turn.started": {
+				const out = [{ type: "start-step" }];
+				out.push(...maybeMetaEvent({ kind: "codex.turn.started" }));
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "turn.completed": {
+				const out = [{ type: "finish-step" }];
+				out.push(...maybeMetaEvent({
+					kind: "codex.turn.completed",
+					usage: event.usage
+				}));
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "turn.failed": {
+				const out = [{
+					type: "error",
+					errorText: event.error.message
+				}, { type: "finish-step" }];
+				out.push(...maybeMetaEvent({
+					kind: "codex.turn.failed",
+					message: event.error.message
+				}));
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "error": {
+				const out = [{
+					type: "error",
+					errorText: event.message
+				}];
+				out.push(...maybeMetaEvent({
+					kind: "codex.error",
+					message: event.message
+				}));
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "item.started":
+			case "item.updated":
+			case "item.completed": return normalizeItemEvent(event.type, event.item);
+			default: return {
+				recognized: false,
+				chunks: []
+			};
+		}
+	}
+	function finish() {
+		const out = [];
+		for (const [id, state] of activeText) if (state.open) {
+			out.push({
+				type: "text-end",
+				id
+			});
+			state.open = false;
+		}
+		for (const [id, state] of activeReasoning) if (state.open) {
+			out.push({
+				type: "reasoning-end",
+				id
+			});
+			state.open = false;
+		}
+		return out;
+	}
+	return {
+		push,
+		finish
+	};
+}
+
+//#endregion
+//#region ../agent-stream-parser/src/claude.ts
+const topLevelSchema = z$1.object({ type: z$1.string() }).passthrough();
+const streamEventSchema = z$1.object({
+	type: z$1.string(),
+	index: z$1.number().optional()
+}).passthrough();
+function createClaudeCodeNormalizer(options = {}) {
+	const includeMetaEvents = options.includeMetaEvents ?? false;
+	const textBlocks = /* @__PURE__ */ new Map();
+	const toolBlocks = /* @__PURE__ */ new Map();
+	let sawStreamEvents = false;
+	function maybeMeta(event) {
+		if (!includeMetaEvents) return [];
+		return [{
+			type: "data-agent-event",
+			data: event
+		}];
+	}
+	function ensureTextBlock(index) {
+		const existing = textBlocks.get(index);
+		if (existing?.open) return [];
+		const id = existing?.id ?? `claude-text-${index}`;
+		textBlocks.set(index, {
+			id,
+			open: true
+		});
+		return [{
+			type: "text-start",
+			id
+		}];
+	}
+	function ensureToolBlock(index, block) {
+		const existing = toolBlocks.get(index);
+		if (existing?.open) return [];
+		const toolCallId = block?.id ?? existing?.toolCallId ?? `claude-tool-${index}`;
+		const toolName = block?.name ?? existing?.toolName ?? "tool";
+		toolBlocks.set(index, {
+			toolCallId,
+			toolName,
+			json: "",
+			open: true
+		});
+		return [{
+			type: "tool-input-start",
+			toolCallId,
+			toolName,
+			dynamic: true
+		}];
+	}
+	function handleStreamEvent(event) {
+		if (!isRecord(event) || typeof event.type !== "string") return [];
+		const out = [];
+		const index = typeof event.index === "number" ? event.index : void 0;
+		switch (event.type) {
+			case "content_block_start": {
+				if (index == null) return [];
+				const block = event.content_block;
+				if (!isRecord(block) || typeof block.type !== "string") return [];
+				sawStreamEvents = true;
+				if (block.type === "text") out.push(...ensureTextBlock(index));
+				else if (block.type === "tool_use") out.push(...ensureToolBlock(index, {
+					id: typeof block.id === "string" ? block.id : void 0,
+					name: typeof block.name === "string" ? block.name : void 0
+				}));
+				return out;
+			}
+			case "content_block_delta": {
+				if (index == null) return [];
+				const delta = event.delta;
+				if (!isRecord(delta) || typeof delta.type !== "string") return [];
+				sawStreamEvents = true;
+				if (delta.type === "text_delta") {
+					const text = typeof delta.text === "string" ? delta.text : "";
+					if (!text) return [];
+					out.push(...ensureTextBlock(index));
+					const id = textBlocks.get(index).id;
+					out.push({
+						type: "text-delta",
+						id,
+						delta: text
+					});
+					return out;
+				}
+				if (delta.type === "input_json_delta") {
+					const partialJson = typeof delta.partial_json === "string" ? delta.partial_json : "";
+					if (!partialJson) return [];
+					out.push(...ensureToolBlock(index));
+					const tool = toolBlocks.get(index);
+					tool.json += partialJson;
+					out.push({
+						type: "tool-input-delta",
+						toolCallId: tool.toolCallId,
+						inputTextDelta: partialJson
+					});
+					return out;
+				}
+				return [];
+			}
+			case "content_block_stop": {
+				if (index == null) return [];
+				sawStreamEvents = true;
+				const text = textBlocks.get(index);
+				if (text?.open) {
+					text.open = false;
+					out.push({
+						type: "text-end",
+						id: text.id
+					});
+				}
+				const tool = toolBlocks.get(index);
+				if (tool?.open) {
+					tool.open = false;
+					let input = tool.json ? tool.json : {};
+					if (typeof input === "string") {
+						const parsed = safeJsonParse(input);
+						if (parsed.ok) input = parsed.value;
+					}
+					out.push({
+						type: "tool-input-available",
+						toolCallId: tool.toolCallId,
+						toolName: tool.toolName,
+						input,
+						dynamic: true
+					});
+				}
+				return out;
+			}
+			default: return [];
+		}
+	}
+	function handleAssistantMessage(message) {
+		if (sawStreamEvents) return [];
+		const blocks = Array.isArray(message.content) ? message.content : [];
+		const out = [];
+		blocks.forEach((block, index) => {
+			if (!isRecord(block) || typeof block.type !== "string") return;
+			if (block.type === "text") {
+				const id = `claude-assistant-text-${index}`;
+				const text = typeof block.text === "string" ? block.text : "";
+				out.push({
+					type: "text-start",
+					id
+				});
+				if (text) out.push({
+					type: "text-delta",
+					id,
+					delta: text
+				});
+				out.push({
+					type: "text-end",
+					id
+				});
+			}
+			if (block.type === "tool_use") {
+				const toolCallId = typeof block.id === "string" ? block.id : `claude-assistant-tool-${index}`;
+				const toolName = typeof block.name === "string" ? block.name : "tool";
+				const input = block.input;
+				out.push({
+					type: "tool-input-available",
+					toolCallId,
+					toolName,
+					input,
+					dynamic: true
+				});
+			}
+		});
+		return out;
+	}
+	function push(chunk) {
+		const parsed = topLevelSchema.safeParse(chunk);
+		if (!parsed.success) return {
+			recognized: false,
+			chunks: []
+		};
+		const msg = parsed.data;
+		const out = [];
+		switch (msg.type) {
+			case "system": {
+				const model = typeof msg.model === "string" ? msg.model : void 0;
+				const sessionId = typeof msg.session_id === "string" ? msg.session_id : typeof msg.sessionId === "string" ? msg.sessionId : void 0;
+				out.push({
+					type: "message-metadata",
+					messageMetadata: {
+						source: "claude-code",
+						model,
+						sessionId
+					}
+				});
+				out.push(...maybeMeta({
+					kind: "claude.system",
+					model,
+					sessionId
+				}));
+				return {
+					recognized: true,
+					chunks: out
+				};
+			}
+			case "stream_event": {
+				sawStreamEvents = true;
+				const event = streamEventSchema.safeParse(msg.event);
+				if (!event.success) return {
+					recognized: false,
+					chunks: []
+				};
+				return {
+					recognized: true,
+					chunks: handleStreamEvent(event.data)
+				};
+			}
+			case "assistant": {
+				const message = msg.message;
+				if (!isRecord(message)) return {
+					recognized: false,
+					chunks: []
+				};
+				return {
+					recognized: true,
+					chunks: handleAssistantMessage(message)
+				};
+			}
+			case "result": return {
+				recognized: true,
+				chunks: maybeMeta({
+					kind: "claude.result",
+					subtype: typeof msg.subtype === "string" ? msg.subtype : void 0,
+					isError: typeof msg.is_error === "boolean" ? msg.is_error : void 0
+				})
+			};
+			default: return {
+				recognized: false,
+				chunks: []
+			};
+		}
+	}
+	function finish() {
+		const out = [];
+		for (const [index, block] of textBlocks) if (block.open) {
+			block.open = false;
+			out.push({
+				type: "text-end",
+				id: block.id
+			});
+		}
+		for (const [index, tool] of toolBlocks) if (tool.open) {
+			tool.open = false;
+			const reason = `Stream ended before tool input completed (index=${index}).`;
+			out.push({
+				type: "tool-input-error",
+				toolCallId: tool.toolCallId,
+				toolName: tool.toolName,
+				input: tool.json,
+				errorText: reason,
+				dynamic: true
+			});
+		}
+		return out;
+	}
+	return {
+		push,
+		finish
+	};
+}
+
+//#endregion
+//#region ../agent-stream-parser/src/normalizer.ts
+function createAgentStreamNormalizer(options) {
+	const unknownChunkPolicy = options.unknownChunkPolicy ?? "ignore";
+	const includeMetaEvents = options.includeMetaEvents ?? false;
+	const emitStartChunk = options.emitStartChunk ?? true;
+	const impl = options.source === "codex" ? createCodexNormalizer({ includeMetaEvents }) : createClaudeCodeNormalizer({ includeMetaEvents });
+	let started = false;
+	function maybeEmitStart() {
+		if (!emitStartChunk || started) return [];
+		started = true;
+		const messageMetadata = { source: options.source };
+		if (options.messageId) return [{
+			type: "start",
+			messageId: options.messageId,
+			messageMetadata
+		}];
+		return [{
+			type: "start",
+			messageMetadata
+		}];
+	}
+	function onUnknownChunk(chunk, reason) {
+		if (unknownChunkPolicy === "ignore") return [];
+		if (unknownChunkPolicy === "throw") throw new Error(`Unknown chunk: ${reason}`);
+		return [{
+			type: "data-agent-unknown",
+			data: {
+				source: options.source,
+				reason,
+				chunk
+			}
+		}];
+	}
+	function push(chunk) {
+		let parsedChunk = chunk;
+		if (typeof chunk === "string") {
+			const parsed = safeJsonParse(chunk);
+			if (!parsed.ok) {
+				const unknown = onUnknownChunk(chunk, `invalid JSON string: ${toErrorMessage(parsed.error)}`);
+				return unknown.length > 0 ? [...maybeEmitStart(), ...unknown] : [];
+			}
+			parsedChunk = parsed.value;
+		}
+		if (!isRecord(parsedChunk) || typeof parsedChunk.type !== "string") {
+			const unknown = onUnknownChunk(chunk, "missing object with string 'type'");
+			return unknown.length > 0 ? [...maybeEmitStart(), ...unknown] : [];
+		}
+		const result = impl.push(parsedChunk);
+		if (result.chunks.length > 0) return [...maybeEmitStart(), ...result.chunks];
+		if (result.recognized) return [];
+		const type = typeof parsedChunk.type === "string" ? parsedChunk.type : "<unknown>";
+		const unknown = onUnknownChunk(chunk, `unrecognized ${options.source} chunk type: ${type}`);
+		return unknown.length > 0 ? [...maybeEmitStart(), ...unknown] : [];
+	}
+	function finish() {
+		const out = impl.finish();
+		if (out.length === 0) return [];
+		return [...maybeEmitStart(), ...out];
+	}
+	return {
+		source: options.source,
+		push,
+		finish
+	};
+}
+
+//#endregion
+//#region src/cli/commands/watch/format.ts
+function tryExtractBashCommand(command) {
+	const wrapper = command.trim().match(/^(?:\/\S*\/bash|bash)\s+(-\S*c)\s+([\s\S]+)$/);
+	if (!wrapper) return void 0;
+	const rest = wrapper[2].trimStart();
+	if (!rest) return void 0;
+	if (rest.startsWith("$'")) {
+		const end = rest.indexOf("'", 2);
+		return end === -1 ? rest.slice(2) : rest.slice(2, end);
+	}
+	if (rest.startsWith("'")) {
+		const end = rest.indexOf("'", 1);
+		return end === -1 ? rest.slice(1) : rest.slice(1, end);
+	}
+	if (rest.startsWith("\"")) {
+		let out = "";
+		let escaped = false;
+		for (let i = 1; i < rest.length; i++) {
+			const ch = rest[i];
+			if (escaped) {
+				out += ch;
+				escaped = false;
+				continue;
+			}
+			if (ch === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (ch === "\"") return out;
+			out += ch;
+		}
+		return out;
+	}
+	return rest.trim();
+}
+function formatCommandExecutionDisplayCommand(command) {
+	const trimmed = command.trim();
+	return tryExtractBashCommand(trimmed)?.trim() || trimmed;
+}
+function formatPreviewLine(label, text, options = {}) {
+	const trimmed = text.trim();
+	if (!trimmed) return void 0;
+	const oneLine = trimmed.replaceAll(/\s+/g, " ");
+	const max = options.maxChars ?? 220;
+	const preview = oneLine.length > max ? oneLine.slice(0, max - 1) + "…" : oneLine;
+	return `${label}: ${options.formatValue ? options.formatValue(preview) : preview}`;
+}
+
+//#endregion
+//#region src/cli/commands/watch.ts
+const PANTHEON_BASE_URL = "https://pantheon-ai.tidb.ai";
+function ensureEnvOrExit(keys) {
+	const missing = keys.filter((key) => !process.env[key]);
+	if (missing.length === 0) return;
+	for (const key of missing) console.error(`${key} environment variable is not set.`);
+	process.exit(1);
+}
+function createDb() {
+	return new Kysely({ dialect: new MysqlDialect({ pool: createPool({
+		uri: process.env.DATABASE_URL,
+		supportBigNumbers: true,
+		bigNumberStrings: true
+	}) }) });
+}
+function formatDurationMs(ms) {
+	const seconds = Math.max(0, Math.floor(ms / 1e3));
+	const minutes = Math.floor(seconds / 60);
+	const hours = Math.floor(minutes / 60);
+	if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+	if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+	return `${seconds}s`;
+}
+function getTaskStartTime(task) {
+	switch (task.status) {
+		case "pending": return task.queued_at;
+		case "running": return task.started_at;
+		case "completed":
+		case "failed": return task.started_at ?? task.queued_at;
+		case "cancelled": return task.queued_at;
+	}
+}
+function getTaskElapsedMs(task, now = /* @__PURE__ */ new Date()) {
+	const start = getTaskStartTime(task);
+	if (!start) return 0;
+	switch (task.status) {
+		case "completed": return task.ended_at.getTime() - start.getTime();
+		case "failed": return (task.ended_at ?? now).getTime() - start.getTime();
+		case "cancelled": return task.cancelled_at.getTime() - start.getTime();
+		default: return now.getTime() - start.getTime();
+	}
+}
+function toStreamSourceFromExecuteAgent(executeAgent) {
+	if (!executeAgent) return void 0;
+	const normalized = executeAgent.toLowerCase();
+	if (normalized.includes("claude")) return "claude-code";
+	if (normalized.includes("codex")) return "codex";
+}
+function detectStreamSourceFromRawPayload(payload) {
+	if (payload.includes("\"type\":\"thread.") || payload.includes("\"type\":\"turn.") || payload.includes("\"type\":\"item.")) return "codex";
+	if (payload.includes("\"type\":\"message_start\"") || payload.includes("\"type\":\"message_delta\"") || payload.includes("\"type\":\"message_stop\"") || payload.includes("\"type\":\"content_block_start\"") || payload.includes("\"type\":\"content_block_delta\"") || payload.includes("\"type\":\"content_block_stop\"")) return "claude-code";
+}
+async function getAgentExecuteAgentMap(db, targets) {
+	const agents = Array.from(new Set(targets.map((t) => t.agent)));
+	if (agents.length === 0) return /* @__PURE__ */ new Map();
+	const configs = await db.selectFrom("agent_project_config").select([
+		"agent",
+		"project_id",
+		"execute_agent"
+	]).where("agent", "in", agents).execute();
+	const map = /* @__PURE__ */ new Map();
+	for (const row of configs) map.set(`${row.agent}|${row.project_id}`, row.execute_agent);
+	return map;
+}
+async function loadTasksByIds(db, ids) {
+	if (ids.length === 0) return [];
+	const rows = await db.selectFrom("task").selectAll().where("id", "in", ids).execute();
+	const out = [];
+	for (const row of rows) {
+		const parsed = taskItemSchema.safeParse(row);
+		if (!parsed.success) {
+			console.error(`Failed to parse task row id=${row.id} agent=${row.agent} status=${row.status}: ${parsed.error.message}`);
+			continue;
+		}
+		out.push({
+			agent: row.agent,
+			task: parsed.data
+		});
+	}
+	return out;
+}
+async function loadTasksForAgent(db, agent) {
+	const rows = await db.selectFrom("task").selectAll().where("agent", "=", agent).execute();
+	const out = [];
+	for (const row of rows) {
+		const parsed = taskItemSchema.safeParse(row);
+		if (!parsed.success) continue;
+		out.push(parsed.data);
+	}
+	return out;
+}
+async function loadAllTasks(db, limit) {
+	const rows = await db.selectFrom("task").selectAll().orderBy("queued_at", "desc").limit(limit).execute();
+	const out = [];
+	for (const row of rows) {
+		const parsed = taskItemSchema.safeParse(row);
+		if (!parsed.success) continue;
+		out.push({
+			agent: row.agent,
+			task: parsed.data
+		});
+	}
+	return out;
+}
+async function resolveWatchTargets(options) {
+	const warnings = [];
+	let selected = [];
+	if (options.taskIds.length > 0) {
+		const uniqueTaskIds = Array.from(new Set(options.taskIds));
+		const found = await loadTasksByIds(options.db, uniqueTaskIds);
+		const foundIds = new Set(found.map((t) => t.task.id));
+		const missing = uniqueTaskIds.filter((id) => !foundIds.has(id));
+		if (missing.length > 0) warnings.push(`Requested task IDs not found: ${missing.join(", ")}`);
+		const byId = new Map(found.map((t) => [t.task.id, t]));
+		selected = uniqueTaskIds.map((id) => byId.get(id)).filter(Boolean);
+		if (selected.length === 0) warnings.push("No requested tasks found; falling back to default selection.");
+	} else if (options.agentNames.length > 0) {
+		const uniqueAgents = Array.from(new Set(options.agentNames));
+		if (uniqueAgents.length === 1) {
+			selected = selectSingleAgentWatchTasks(await loadTasksForAgent(options.db, uniqueAgents[0]), { finishedLimit: 3 }).map((task) => ({
+				agent: uniqueAgents[0],
+				task
+			}));
+			if (selected.length === 0) warnings.push(`No tasks found for agent ${uniqueAgents[0]}; falling back to default selection.`);
+		} else {
+			selected = selectMultiAgentWatchTasks(await Promise.all(uniqueAgents.map(async (agent) => {
+				return (await loadTasksForAgent(options.db, agent)).map((task) => ({
+					agent,
+					task
+				}));
+			})).then((groups) => groups.flat()), uniqueAgents);
+			const foundAgents = new Set(selected.map((t) => t.agent));
+			const missing = uniqueAgents.filter((agent) => !foundAgents.has(agent));
+			if (missing.length > 0) warnings.push(`No tasks found for agent(s): ${missing.join(", ")}`);
+			if (selected.length === 0) warnings.push("No requested agent tasks found; falling back to default selection.");
+		}
+	} else warnings.push("No targets specified; selecting up to 3 agents automatically.");
+	if (selected.length === 0) selected = selectFallbackWatchTasks(await loadAllTasks(options.db, 500), { agentLimit: 3 });
+	const executeAgentMap = await getAgentExecuteAgentMap(options.db, selected);
+	return {
+		targets: selected.map((entry) => ({
+			...entry,
+			executeAgent: executeAgentMap.get(`${entry.agent}|${entry.task.project_id}`)
+		})),
+		warnings
+	};
+}
+function makeStreamUrl(streamId) {
+	return `${PANTHEON_BASE_URL}/ai_stream_proxy/v2/streams/${encodeURIComponent(streamId)}/stream?format=opaque-stream-json`;
+}
+async function buildStepSnapshot(options) {
+	const aggregator = new WatchStepAggregator();
+	let inferredSource;
+	let normalizer = void 0;
+	const url = makeStreamUrl(options.streamId);
+	const res = await fetch(url, { headers: {
+		Authorization: `Bearer ${process.env.PANTHEON_API_KEY}`,
+		Accept: "text/event-stream"
+	} });
+	if (!res.body) return { step: aggregator.snapshot() };
+	await consumeOpaqueSseStream({
+		stream: res.body,
+		idleTimeoutMs: options.idleTimeoutMs,
+		onWarning: (warning) => aggregator.pushUiChunk({
+			type: "data-agent-unknown",
+			data: { reason: warning }
+		}),
+		onData: (payload) => {
+			if (!normalizer) {
+				inferredSource = options.preferredSource ?? detectStreamSourceFromRawPayload(payload) ?? "codex";
+				normalizer = createAgentStreamNormalizer({
+					source: inferredSource,
+					emitStartChunk: false,
+					includeMetaEvents: false,
+					unknownChunkPolicy: "emit"
+				});
+			}
+			const chunks = normalizer.push(payload);
+			aggregator.pushUiChunks(chunks);
+		}
+	});
+	if (normalizer) aggregator.pushUiChunks(normalizer.finish());
+	return {
+		step: aggregator.snapshot(),
+		inferredSource
+	};
+}
+async function fetchBranchSnapshot(options) {
+	const { task } = options;
+	if (task.status !== "running" && task.status !== "completed" && task.status !== "failed") return {};
+	const branchId = "branch_id" in task ? task.branch_id ?? void 0 : void 0;
+	if (!branchId) return {};
+	const branch = await getPantheonBranchInfo({
+		projectId: task.project_id,
+		branchId
+	});
+	return {
+		branch,
+		stepIndex: branch.latest_snap?.step_index,
+		streamId: branch.latest_snap?.event_stream_id ?? void 0
+	};
+}
+function printSnapshotLineBlock(lines) {
+	lines.forEach((line) => console.log(line));
+}
+const ANSI = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	cyan: "\x1B[36m",
+	gray: "\x1B[90m"
+};
+function useAnsiStyles() {
+	if (!process.stdout.isTTY) return false;
+	if (process.env.NO_COLOR != null) return false;
+	return true;
+}
+function sgrWrap(text, code, enabled) {
+	return enabled ? `${code}${text}${ANSI.reset}` : text;
+}
+function bold(text, enabled) {
+	return sgrWrap(text, ANSI.bold, enabled);
+}
+function dim(text, enabled) {
+	return sgrWrap(text, ANSI.dim, enabled);
+}
+function gray(text, enabled) {
+	return sgrWrap(text, ANSI.gray, enabled);
+}
+function red(text, enabled) {
+	return sgrWrap(text, ANSI.red, enabled);
+}
+function green(text, enabled) {
+	return sgrWrap(text, ANSI.green, enabled);
+}
+function yellow(text, enabled) {
+	return sgrWrap(text, ANSI.yellow, enabled);
+}
+function cyan(text, enabled) {
+	return sgrWrap(text, ANSI.cyan, enabled);
+}
+function kv(label, value, style) {
+	return `${dim(`${label}:`, style)} ${value}`;
+}
+function formatTaskStatus(status, style) {
+	switch (status) {
+		case "running": return yellow(status, style);
+		case "completed": return green(status, style);
+		case "failed": return red(status, style);
+		case "pending": return cyan(status, style);
+		case "cancelled": return gray(status, style);
+	}
+}
+function formatBranchStatus(status, style) {
+	if (!status) return gray("(no branch)", style);
+	switch (status) {
+		case "succeed": return green(status, style);
+		case "failed": return red(status, style);
+		case "running":
+		case "pending": return yellow(status, style);
+		case "manifesting":
+		case "ready_for_manifest": return cyan(status, style);
+		default: return gray(status, style);
+	}
+}
+function formatToolLabel(tool, style) {
+	const name = tool.toolName ?? "<tool>";
+	if (name === "command_execution") {
+		const title = typeof tool.title === "string" ? tool.title : "";
+		const inputCommand = typeof tool.input?.command === "string" ? tool.input.command : "";
+		const raw = title || inputCommand;
+		const display = raw ? formatCommandExecutionDisplayCommand(raw) : "(unknown command)";
+		return `${bold("$", style)} ${cyan(display, style)}`;
+	}
+	const renderedName = bold(name, style);
+	if (!tool.title) return renderedName;
+	return `${renderedName}: ${tool.title}`;
+}
+function formatToolSummaryLine(tool, style) {
+	const label = formatToolLabel(tool, style);
+	const id = gray(tool.toolCallId, style);
+	switch (tool.status) {
+		case "completed": return `${green("✓", style)} ${label} (${id})`;
+		case "failed": return `${red("✗", style)} ${label} (${id})`;
+		default: return `${yellow("…", style)} ${label} (${id})`;
+	}
+}
+function toDisplayLines(text) {
+	return text.replaceAll("\r\n", "\n").split("\n");
+}
+function wrapCollapsedWhitespaceToWidth(text, width) {
+	const collapsed = text.trim().replaceAll(/\s+/g, " ");
+	if (!collapsed) return [];
+	if (width <= 0) return [collapsed];
+	const words = collapsed.split(" ");
+	const lines = [];
+	let current = "";
+	function pushLongWord(word) {
+		for (let i = 0; i < word.length; i += width) {
+			const chunk = word.slice(i, i + width);
+			if (chunk.length === width) lines.push(chunk);
+			else current = chunk;
+		}
+	}
+	for (const word of words) {
+		if (!current) {
+			if (word.length <= width) current = word;
+			else pushLongWord(word);
+			continue;
+		}
+		if (current.length + 1 + word.length <= width) {
+			current += ` ${word}`;
+			continue;
+		}
+		lines.push(current);
+		current = "";
+		if (word.length <= width) current = word;
+		else pushLongWord(word);
+	}
+	if (current) lines.push(current);
+	return lines;
+}
+function formatWrappedPreviewLines(label, text, options) {
+	const trimmed = text.trim();
+	if (!trimmed) return [];
+	const prefixVisible = visibleLength(`${label}: `);
+	const kept = trimLinesWithEllipsis(wrapCollapsedWhitespaceToWidth(trimmed, Math.max(10, options.widthHint - prefixVisible)), options.maxLines);
+	const indent = " ".repeat(prefixVisible);
+	return kept.map((line, idx) => {
+		const value = options.formatValue ? options.formatValue(line) : line;
+		return idx === 0 ? `${label}: ${value}` : `${indent}${value}`;
+	});
+}
+function trimLinesWithEllipsis(lines, maxLines) {
+	if (maxLines <= 0) return [];
+	if (lines.length <= maxLines) return lines;
+	const kept = lines.slice(0, maxLines);
+	const lastIndex = kept.length - 1;
+	const last = kept[lastIndex]?.trimEnd() ?? "";
+	kept[lastIndex] = last ? `${last}…` : "…";
+	return kept;
+}
+function formatToolResultPreviewLines(tool, options) {
+	if (tool.status === "in_progress") return [];
+	if (options.maxLines <= 0) return [];
+	if (tool.status === "failed") {
+		const lines = trimLinesWithEllipsis(toDisplayLines(tool.errorText ?? "(no error text)"), options.maxLines);
+		const prefix = dim("error:", options.style);
+		return lines.map((line, idx) => idx === 0 ? `${prefix} ${line}` : `       ${line}`);
+	}
+	if (tool.output == null) return [`${dim("output:", options.style)} (none)`];
+	if (tool.toolName === "command_execution") {
+		const output = tool.output;
+		const exitCode = output?.exit_code ?? null;
+		const outLines = trimLinesWithEllipsis(toDisplayLines((typeof output?.aggregated_output === "string" ? output.aggregated_output : "").trimEnd()), options.maxLines);
+		const exitCodeLabel = typeof exitCode === "number" ? exitCode === 0 ? green(String(exitCode), options.style) : red(String(exitCode), options.style) : gray(String(exitCode), options.style);
+		const outputPrefix = dim("output:", options.style);
+		if (outLines.length === 0) return [`${outputPrefix} exit_code=${exitCodeLabel}`];
+		return outLines.map((line, idx) => idx === 0 ? `${outputPrefix} exit_code=${exitCodeLabel}  ${line}` : `                    ${line}`);
+	}
+	const lines = trimLinesWithEllipsis(toDisplayLines(inspect(tool.output, {
+		depth: 6,
+		maxArrayLength: 50,
+		maxStringLength: 1e3,
+		compact: true,
+		breakLength: Math.max(20, options.widthHint)
+	})), options.maxLines);
+	const outputPrefix = dim("output:", options.style);
+	return lines.map((line, idx) => idx === 0 ? `${outputPrefix} ${line}` : `        ${line}`);
+}
+function formatToolBlocks(step, options) {
+	const tools = options.maxTools != null ? step.toolActions.slice(-options.maxTools) : step.toolActions;
+	if (tools.length === 0) return [`  ${gray("(none)", options.style)}`];
+	const widthHint = Math.max(20, options.widthHint);
+	const out = [];
+	for (const tool of tools) {
+		out.push(`  ${formatToolSummaryLine(tool, options.style)}`);
+		formatToolResultPreviewLines(tool, {
+			maxLines: options.maxResultLines,
+			widthHint: widthHint - 4,
+			style: options.style
+		}).forEach((line) => out.push(`    ${line}`));
+	}
+	return out.map((line) => clip(line, widthHint));
+}
+const ANSI_SGR_REGEX = /\u001b\[[0-9;]*m/g;
+function visibleLength(value) {
+	return value.replaceAll(ANSI_SGR_REGEX, "").length;
+}
+function sliceSgrByVisibleWidth(value, maxVisible) {
+	if (maxVisible <= 0) return "";
+	let out = "";
+	let visible = 0;
+	for (let i = 0; i < value.length; i++) {
+		if (visible >= maxVisible) break;
+		const ch = value[i];
+		if (ch === "\x1B" && value[i + 1] === "[") {
+			const end = value.indexOf("m", i);
+			if (end === -1) break;
+			out += value.slice(i, end + 1);
+			i = end;
+			continue;
+		}
+		out += ch;
+		visible += 1;
+	}
+	return out;
+}
+function clip(value, maxVisible) {
+	if (maxVisible <= 0) return "";
+	if (visibleLength(value) <= maxVisible) return value;
+	if (maxVisible === 1) return "…";
+	const sliced = sliceSgrByVisibleWidth(value, maxVisible - 1);
+	return `${sliced}…${sliced.includes("\x1B[") ? ANSI.reset : ""}`;
+}
+function createWatchCommand(version) {
+	return createCommand("watch").version(version).description("Inspect task progress via live/near-live stream data (internal tooling).").option("--tasks <ids>", "Comma-separated task IDs to watch.", parseCommaList, []).option("--agents <names>", "Comma-separated agent names to watch.", parseCommaList, []).option("--follow", "Follow mode: live updating TUI.", false).option("--idle-timeout-seconds <seconds>", "Snapshot mode: stop reading a stream after this many seconds with no new messages.", (val) => parseFloat(val), 3).action(async function() {
+		ensureEnvOrExit(["PANTHEON_API_KEY", "DATABASE_URL"]);
+		const options = this.opts();
+		if (options.tasks.length > 0 && options.agents.length > 0) {
+			console.error("Use either --tasks or --agents, not both.");
+			process.exit(1);
+		}
+		const idleTimeoutMs = Math.max(0, options.idleTimeoutSeconds * 1e3);
+		const db = createDb();
+		try {
+			const { targets, warnings } = await resolveWatchTargets({
+				db,
+				taskIds: options.tasks,
+				agentNames: options.agents
+			});
+			warnings.forEach((w) => console.error(`warning: ${w}`));
+			if (targets.length === 0) {
+				console.error("No tasks found to watch.");
+				process.exit(1);
+			}
+			if (!options.follow) {
+				const style = useAnsiStyles();
+				const widthHint = process.stdout.columns ?? 120;
+				const now = /* @__PURE__ */ new Date();
+				for (const target of targets) {
+					const { task } = target;
+					const elapsedMs = getTaskElapsedMs(task, now);
+					let branchInfo = {};
+					try {
+						branchInfo = await fetchBranchSnapshot({ task });
+					} catch (error) {
+						console.error(`warning: failed to fetch branch info for task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
+					}
+					const preferredSource = toStreamSourceFromExecuteAgent(target.executeAgent);
+					let stepSnapshot = void 0;
+					let inferredSource = void 0;
+					if (branchInfo.streamId) try {
+						const result = await buildStepSnapshot({
+							streamId: branchInfo.streamId,
+							preferredSource,
+							idleTimeoutMs
+						});
+						stepSnapshot = result.step;
+						inferredSource = result.inferredSource;
+					} catch (error) {
+						console.error(`warning: failed to read stream for task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
+					}
+					const lines = [];
+					const sep = gray(" • ", style);
+					lines.push([
+						kv("task", task.id, style),
+						kv("status", formatTaskStatus(task.status, style), style),
+						kv("agent", target.agent, style)
+					].join(sep));
+					const branchId = "branch_id" in task ? task.branch_id ?? void 0 : void 0;
+					const mergedBranchLine = [
+						kv("project", task.project_id, style),
+						branchId ? kv("branch", branchId, style) : void 0,
+						branchId || branchInfo.branch?.status ? kv("branch_status", formatBranchStatus(branchInfo.branch?.status, style), style) : void 0,
+						branchInfo.stepIndex != null ? kv("step", String(branchInfo.stepIndex), style) : void 0
+					].filter(Boolean).join(sep);
+					if (mergedBranchLine) lines.push(mergedBranchLine);
+					if (branchInfo.streamId) {
+						const src = preferredSource ?? inferredSource;
+						const mergedStreamLine = [kv("stream", branchInfo.streamId, style), src ? kv("source", src, style) : void 0].filter(Boolean).join(sep);
+						if (mergedStreamLine) lines.push(mergedStreamLine);
+					}
+					const start = getTaskStartTime(task);
+					const mergedTimingLine = [start ? kv("started", start.toISOString(), style) : void 0, kv("elapsed", formatDurationMs(elapsedMs), style)].filter(Boolean).join(sep);
+					if (mergedTimingLine) lines.push(mergedTimingLine);
+					if (stepSnapshot) {
+						const reasoningLine = formatPreviewLine(dim("reasoning", style), stepSnapshot.leadingReasoning, { formatValue: (value) => gray(value, style) });
+						if (reasoningLine) lines.push(reasoningLine);
+						lines.push(bold("tools:", style));
+						lines.push(...formatToolBlocks(stepSnapshot, {
+							style,
+							widthHint,
+							maxResultLines: 3
+						}));
+						const messageLine = formatPreviewLine(dim("message", style), stepSnapshot.leadingText);
+						if (messageLine) lines.push(messageLine);
+						if (stepSnapshot.warnings.length > 0) lines.push(kv("warnings", yellow(`${stepSnapshot.warnings.length} (unknown=${stepSnapshot.unknownEventCount})`, style), style));
+					} else lines.push(`${bold("tools:", style)} ${gray("(no stream)", style)}`);
+					printSnapshotLineBlock(lines.map((line) => clip(line, widthHint)));
+					console.log("");
+				}
+				return;
+			}
+			if (!process.stdout.isTTY) {
+				console.error("--follow requires a TTY.");
+				process.exit(1);
+			}
+			const abortController = new AbortController();
+			const onSigInt = () => abortController.abort();
+			process.on("SIGINT", onSigInt);
+			const runtime = targets.map((target) => ({
+				target,
+				aggregator: new WatchStepAggregator({ maxLogLines: 120 }),
+				streamDone: false
+			}));
+			function isTerminalBranchStatus(status) {
+				return status === "succeed" || status === "failed";
+			}
+			async function startStream(rt, streamId) {
+				rt.streamAbort?.abort();
+				rt.streamAbort = new AbortController();
+				rt.streamDone = false;
+				const preferred = toStreamSourceFromExecuteAgent(rt.target.executeAgent);
+				rt.source = preferred;
+				const url = makeStreamUrl(streamId);
+				(async () => {
+					try {
+						const res = await fetch(url, {
+							headers: {
+								Authorization: `Bearer ${process.env.PANTHEON_API_KEY}`,
+								Accept: "text/event-stream"
+							},
+							signal: rt.streamAbort.signal
+						});
+						if (!res.body) {
+							rt.lastError = "missing response body";
+							rt.streamDone = true;
+							return;
+						}
+						let normalizer;
+						await consumeOpaqueSseStream({
+							stream: res.body,
+							signal: rt.streamAbort.signal,
+							onWarning: (warning) => rt.aggregator.pushUiChunk({
+								type: "data-agent-unknown",
+								data: { reason: warning }
+							}),
+							onData: (payload) => {
+								if (!normalizer) {
+									rt.source = preferred ?? detectStreamSourceFromRawPayload(payload) ?? "codex";
+									normalizer = createAgentStreamNormalizer({
+										source: rt.source,
+										emitStartChunk: false,
+										includeMetaEvents: false,
+										unknownChunkPolicy: "emit"
+									});
+								}
+								rt.aggregator.pushUiChunks(normalizer.push(payload));
+							}
+						});
+						if (normalizer) rt.aggregator.pushUiChunks(normalizer.finish());
+						rt.streamDone = true;
+					} catch (error) {
+						if (rt.streamAbort?.signal.aborted) {
+							rt.streamDone = true;
+							return;
+						}
+						rt.lastError = error instanceof Error ? error.message : String(error);
+						rt.streamDone = true;
+					}
+				})();
+			}
+			async function pollBranchesOnce() {
+				await Promise.all(runtime.map(async (rt) => {
+					const { task } = rt.target;
+					if (task.status !== "running" && task.status !== "completed" && task.status !== "failed") return;
+					const branchId = "branch_id" in task ? task.branch_id ?? void 0 : void 0;
+					if (!branchId) return;
+					try {
+						const branch = await getPantheonBranchInfo({
+							projectId: task.project_id,
+							branchId
+						});
+						rt.branch = branch;
+						rt.stepIndex = branch.latest_snap?.step_index;
+						const nextStreamId = branch.latest_snap?.event_stream_id ?? void 0;
+						if (nextStreamId && nextStreamId !== rt.streamId) {
+							rt.streamId = nextStreamId;
+							rt.aggregator = new WatchStepAggregator({ maxLogLines: 120 });
+							await startStream(rt, nextStreamId);
+						}
+					} catch (error) {
+						rt.lastError = error instanceof Error ? error.message : String(error);
+					}
+				}));
+			}
+			const screen = blessed.screen({
+				smartCSR: true,
+				title: "pantheon-agents watch"
+			});
+			screen.key(["q", "C-c"], () => abortController.abort());
+			const footer = blessed.box({
+				parent: screen,
+				bottom: 0,
+				left: 0,
+				height: 1,
+				width: "100%",
+				tags: false,
+				content: "Ctrl+C to exit • q to quit",
+				style: { fg: "gray" }
+			});
+			const panes = runtime.map(() => blessed.box({
+				parent: screen,
+				top: 0,
+				left: 0,
+				height: "100%-1",
+				width: "100%",
+				border: "line",
+				tags: false,
+				scrollable: false,
+				wrap: false,
+				style: { border: { fg: "gray" } }
+			}));
+			let lastGlobalError;
+			function layoutPanes(columns) {
+				const n = panes.length;
+				for (let i = 0; i < n; i++) {
+					const left = Math.floor(i * columns / n);
+					const right = Math.floor((i + 1) * columns / n);
+					panes[i].left = left;
+					panes[i].width = Math.max(1, right - left);
+				}
+			}
+			const renderTimer = setInterval(() => {
+				const style = useAnsiStyles();
+				const columns = Math.max(40, screen.width ?? 120);
+				const rows = Math.max(8, screen.height ?? 24);
+				layoutPanes(columns);
+				const paneWidth = Math.max(1, Math.floor(columns / runtime.length));
+				const paneInnerWidth = Math.max(0, paneWidth - 2);
+				const paneOuterHeight = Math.max(1, rows - 1);
+				const maxContentLines = Math.max(0, paneOuterHeight - 2);
+				const nextFooterParts = ["Ctrl+C to exit", "q to quit"];
+				if (lastGlobalError) nextFooterParts.push(`error: ${lastGlobalError}`);
+				footer.setContent(nextFooterParts.join(" • "));
+				runtime.forEach((rt, idx) => {
+					const { task } = rt.target;
+					const step = rt.aggregator.snapshot();
+					const elapsed = formatDurationMs(getTaskElapsedMs(task, /* @__PURE__ */ new Date()));
+					const title = [
+						rt.target.agent,
+						`task ${task.id}`,
+						formatTaskStatus(task.status, style),
+						formatBranchStatus(rt.branch?.status, style),
+						rt.stepIndex != null ? `step ${rt.stepIndex}` : void 0,
+						`elapsed ${elapsed}`
+					].filter(Boolean).join(gray(" • ", style));
+					const branchId = "branch_id" in task ? task.branch_id ?? void 0 : void 0;
+					const headerLines = [kv("project", task.project_id, style), kv("branch", branchId ? branchId : gray("(no branch)", style), style)];
+					const reasoningLines = formatWrappedPreviewLines(dim("reasoning", style), step.leadingReasoning, {
+						maxLines: 4,
+						widthHint: paneInnerWidth,
+						formatValue: (value) => gray(value, style)
+					});
+					const messageLine = formatPreviewLine(dim("message", style), step.leadingText);
+					const extraLines = [];
+					if (rt.lastError) extraLines.push(kv("error", red(rt.lastError, style), style));
+					if (step.warnings.length > 0) extraLines.push(kv("warnings", yellow(`${step.warnings.length} (unknown=${step.unknownEventCount})`, style), style));
+					const toolLines = step.toolActions.filter((t) => t.toolName !== "command_execution").slice(-3).map((tool) => formatToolSummaryLine(tool, style));
+					const baseLines = [
+						...headerLines,
+						...reasoningLines,
+						...toolLines,
+						...messageLine ? [messageLine] : [],
+						...extraLines
+					];
+					const remainingForLogs = Math.max(0, maxContentLines - baseLines.length);
+					const logLines = step.logLines.slice(-remainingForLogs);
+					panes[idx].setLabel(title);
+					panes[idx].setContent([...baseLines, ...logLines].map((line) => clip(line, paneInnerWidth)).join("\n"));
+				});
+				screen.render();
+			}, 300);
+			let pollTimer;
+			let doneTimer;
+			try {
+				await pollBranchesOnce();
+				if (abortController.signal.aborted) return;
+				pollTimer = setInterval(() => {
+					pollBranchesOnce().catch((e) => {
+						lastGlobalError = e instanceof Error ? e.message : String(e);
+					});
+				}, 2e3);
+				await new Promise((resolve) => {
+					let resolved = false;
+					const resolveOnce = () => {
+						if (resolved) return;
+						resolved = true;
+						if (doneTimer) {
+							clearInterval(doneTimer);
+							doneTimer = void 0;
+						}
+						resolve();
+					};
+					abortController.signal.addEventListener("abort", resolveOnce, { once: true });
+					if (abortController.signal.aborted) {
+						resolveOnce();
+						return;
+					}
+					const terminalGraceMs = Math.max(1e3, idleTimeoutMs);
+					let terminalSince;
+					doneTimer = setInterval(() => {
+						const now = Date.now();
+						if (!runtime.every((rt) => isTerminalBranchStatus(rt.branch?.status))) {
+							terminalSince = void 0;
+							return;
+						}
+						terminalSince ??= now;
+						if (runtime.every((rt) => !rt.streamId || rt.streamDone)) {
+							resolveOnce();
+							return;
+						}
+						if (now - terminalSince >= terminalGraceMs) resolveOnce();
+					}, 1e3);
+				});
+			} finally {
+				process.off("SIGINT", onSigInt);
+				clearInterval(renderTimer);
+				if (pollTimer) clearInterval(pollTimer);
+				if (doneTimer) clearInterval(doneTimer);
+				runtime.forEach((rt) => rt.streamAbort?.abort());
+				screen.destroy();
+			}
+		} finally {
+			await db.destroy();
+		}
+	});
+}
+
 //#endregion
 //#region src/cli/index.ts
-const program = new Command().name("pantheon-agents").description("Pantheon agents CLI").version(version$1).showHelpAfterError().showSuggestionAfterError().addHelpCommand().addCommand(createAddTaskCommand(version$1)).addCommand(createConfigAgentCommand(version$1)).addCommand(createDeleteTaskCommand(version$1)).addCommand(createReconfigAgentCommand(version$1)).addCommand(createRunAgentCommand(version$1)).addCommand(createServerCommand(version$1)).addCommand(createShowConfigCommand(version$1)).addCommand(createShowTasksCommand(version$1));
+const program = new Command().name("pantheon-agents").description("Pantheon agents CLI").version(version$1).showHelpAfterError().showSuggestionAfterError().addHelpCommand().addCommand(createAddTaskCommand(version$1)).addCommand(createConfigAgentCommand(version$1)).addCommand(createDeleteTaskCommand(version$1)).addCommand(createReconfigAgentCommand(version$1)).addCommand(createRunAgentCommand(version$1)).addCommand(createServerCommand(version$1)).addCommand(createShowConfigCommand(version$1)).addCommand(createShowTasksCommand(version$1)).addCommand(createWatchCommand(version$1));
 async function main() {
 	if (process$1.argv.length <= 2) {
 		program.outputHelp();