@pantheon.ai/agents 0.0.10 → 0.0.12

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-import * as process$1 from "node:process";
-import { createCommand } from "commander";
+import { Command, createCommand } from "commander";
+import process$1 from "node:process";
 import * as fs from "node:fs";
 import path from "node:path";
 import { multistream, pino, transport } from "pino";
@@ -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.10";
+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) {
@@ -9780,38 +10109,37 @@ async function runAgent(name, options, logger) {
 }
 async function configAgent(name, options) {
 	const provider = new TaskListTidbProvider(name, pino());
-	const previousConfig = await provider.getAgentConfig(options.projectId);
-	if (previousConfig) if (previousConfig.role === options.role) {
-		console.log(`Agent ${name} already configured as ${options.role} for project ${options.projectId}.`);
-		console.log(`Base branch id: ${previousConfig.base_branch_id}`);
-		await provider.close();
-		return;
-	} else {
-		console.error(`Agent ${name} already configured as ${previousConfig.role} for project ${options.projectId}.`);
-		console.error(`Base branch id: ${previousConfig.base_branch_id}`);
-		console.error(`Cannot change role to ${options.role}`);
-		await provider.close();
-		process.exitCode = 1;
-		return;
-	}
-	console.log(`Configuring agent ${name} as ${options.role} for project ${options.projectId}.`);
-	if (!options.rootBranchId) {
-		console.log("No root branch id specified, using project root branch.");
-		const project = await getPantheonProjectInfo({ projectId: options.projectId });
-		if (!project.root_branch_id) {
-			console.error(`Project ${options.projectId} has no root branch. Project status is ${project.status}`);
-			await provider.close();
+	try {
+		const previousConfig = await provider.getAgentConfig(options.projectId);
+		if (previousConfig) {
+			if (previousConfig.role === options.role) {
+				console.log(`Agent ${name} already configured as ${options.role} for project ${options.projectId}.`);
+				console.log(`Base branch id: ${previousConfig.base_branch_id}`);
+				return;
+			}
+			console.error(`Agent ${name} already configured as ${previousConfig.role} for project ${options.projectId}.`);
+			console.error(`Base branch id: ${previousConfig.base_branch_id}`);
+			console.error(`Cannot change role to ${options.role}`);
 			process.exitCode = 1;
 			return;
 		}
-		options.rootBranchId = project.root_branch_id;
-	}
-	if (options.bootstrap) {
-		const branchId = await executeOnPantheon({
-			projectId: options.projectId,
-			branchId: options.rootBranchId,
-			agent: "codex",
-			prompt: `You must follow these instructions":
+		console.log(`Configuring agent ${name} as ${options.role} for project ${options.projectId}.`);
+		if (!options.rootBranchId) {
+			console.log("No root branch id specified, using project root branch.");
+			const project = await getPantheonProjectInfo({ projectId: options.projectId });
+			if (!project.root_branch_id) {
+				console.error(`Project ${options.projectId} has no root branch. Project status is ${project.status}`);
+				process.exitCode = 1;
+				return;
+			}
+			options.rootBranchId = project.root_branch_id;
+		}
+		if (options.bootstrap) {
+			const branchId = await executeOnPantheon({
+				projectId: options.projectId,
+				branchId: options.rootBranchId,
+				agent: "codex",
+				prompt: `You must follow these instructions":
 1. Clone the main branch from ${options.prototypeUrl} to a temporary directory (<pantheon-agents> in follow instructions references to this directory).
 2. Copy the <pantheon-agents>/agents/${options.role}/AGENTS.md to \`<workspace>/AGENTS.md\`.
 3. Copy the <pantheon-agents>/agents/${options.role}/skills directory to \`<workspace>/.codex/skills\` if the source directory exists.
@@ -9825,58 +10153,61 @@ Validate <workspace>: check if files and directorys exists:
 
 Finally, outputs the first 5 lines of <workspace>/AGENTS.md and the skills list in <workspace>/.codex/skills
 `
-		});
-		let retried = 0;
-		const maxRetries = 3;
-		let i = 0;
-		console.log(`Bootstrap branch created: ${branchId}. Waiting for ready... [poll interval = 10s]`);
-		while (true) {
-			await new Promise((resolve) => {
-				setTimeout(resolve, 1e4);
 			});
-			const result = await getPantheonBranch({
-				branchId,
-				projectId: options.projectId,
-				getOutputIfFinished: true
-			}).then((result) => {
-				retried = 0;
-				return result;
-			}).catch((reason) => {
-				if (retried < maxRetries) {
-					retried++;
-					return { state: "others" };
-				} else throw new Error(`Failed to get bootstrap branch status. Retry ${retried} times. Last error: ${getErrorMessage(reason)}`);
+			let retried = 0;
+			const maxRetries = 3;
+			let i = 0;
+			console.log(`Bootstrap branch created: ${branchId}. Waiting for ready... [poll interval = 10s]`);
+			while (true) {
+				await new Promise((resolve) => {
+					setTimeout(resolve, 1e4);
+				});
+				const result = await getPantheonBranch({
+					branchId,
+					projectId: options.projectId,
+					getOutputIfFinished: true
+				}).then((result) => {
+					retried = 0;
+					return result;
+				}).catch((reason) => {
+					if (retried < maxRetries) {
+						retried++;
+						return { state: "others" };
+					}
+					throw new Error(`Failed to get bootstrap branch status. Retry ${retried} times. Last error: ${getErrorMessage(reason)}`);
+				});
+				if (result.state === "failed") {
+					console.error("Bootstrap failed: " + result.error);
+					process.exitCode = 1;
+					return;
+				}
+				if (result.state === "succeed") {
+					console.log("Bootstrap succeeded. Output is:");
+					console.log(result.output);
+					break;
+				}
+				console.log(`Bootstrap in progress... [${++i}]`);
+			}
+			await provider.setAgentConfig({
+				project_id: options.projectId,
+				base_branch_id: branchId,
+				execute_agent: options.executeAgent,
+				role: options.role,
+				skills: options.skills,
+				prototype_url: options.prototypeUrl
 			});
-			if (result.state === "failed") {
-				console.error("Bootstrap failed: " + result.error);
-				await provider.close();
-				process.exit(1);
-			}
-			if (result.state === "succeed") {
-				console.log("Bootstrap succeeded. Output is:");
-				console.log(result.output);
-				break;
-			}
-			console.log(`Bootstrap in progress... [${++i}]`);
-		}
-		await provider.setAgentConfig({
+		} else await provider.setAgentConfig({
 			project_id: options.projectId,
-			base_branch_id: branchId,
+			base_branch_id: options.rootBranchId,
 			execute_agent: options.executeAgent,
 			role: options.role,
 			skills: options.skills,
 			prototype_url: options.prototypeUrl
 		});
-	} else await provider.setAgentConfig({
-		project_id: options.projectId,
-		base_branch_id: options.rootBranchId,
-		execute_agent: options.executeAgent,
-		role: options.role,
-		skills: options.skills,
-		prototype_url: options.prototypeUrl
-	});
-	console.log(`Agent ${name} configured successfully.`);
-	await provider.close();
+		console.log(`Agent ${name} configured successfully.`);
+	} finally {
+		await provider.close();
+	}
 }
 async function reconfigAgentWithDeps(name, options, deps) {
 	const previousConfig = await deps.provider.getAgentConfig(options.projectId);
@@ -9939,15 +10270,18 @@ async function reconfigAgent(name, options) {
 }
 async function addTask(name, options) {
 	const provider = new TaskListTidbProvider(name, pino());
-	const config = await provider.getAgentConfig(options.projectId);
-	if (!config) throw new Error(`Agent ${name} not configured for project ${options.projectId}`);
-	const task = await provider.createTask({
-		task: options.prompt,
-		project_id: options.projectId,
-		base_branch_id: config.base_branch_id
-	});
-	console.log(`Task ${task.task} queued successfully.`);
-	await provider.close();
+	try {
+		const config = await provider.getAgentConfig(options.projectId);
+		if (!config) throw new Error(`Agent ${name} not configured for project ${options.projectId}`);
+		const task = await provider.createTask({
+			task: options.prompt,
+			project_id: options.projectId,
+			base_branch_id: config.base_branch_id
+		});
+		console.log(`Queued task ${task.id} successfully.`);
+	} finally {
+		await provider.close();
+	}
 }
 async function deleteTask(agentName, taskId) {
 	const provider = new TaskListTidbProvider(agentName, pino());
@@ -10102,11 +10436,22 @@ async function assertsSingleton(logger, pidFile) {
 	}
 }
 
+//#endregion
+//#region src/cli/utils/env.ts
+function ensureEnv(keys) {
+	const missing = keys.filter((key) => !process.env[key]);
+	if (missing.length === 0) return true;
+	for (const key of missing) console.error(`${key} environment variable is not set.`);
+	process.exitCode = 1;
+	return false;
+}
+
 //#endregion
 //#region src/cli/commands/add-task.ts
 function createAddTaskCommand(version) {
-	return createCommand("pantheon-agents add-task").version(version).description("Add a task to an agent").argument("<name>", "The name of the agent.").argument("<project-id>", "The project id of the agent.").argument("<task-prompt>", "The prompt of the task.").action(async function() {
+	return createCommand("add-task").version(version).description("Add a task to an agent").argument("<name>", "The name of the agent.").argument("<project-id>", "The project id of the agent.").argument("<task-prompt>", "The prompt of the task.").action(async function() {
 		const [name, projectId, taskPrompt] = this.args;
+		if (!ensureEnv(["DATABASE_URL"])) return;
 		await addTask(name, {
 			projectId,
 			prompt: taskPrompt
@@ -10117,12 +10462,16 @@ function createAddTaskCommand(version) {
 //#endregion
 //#region src/cli/commands/config.ts
 function createConfigAgentCommand(version) {
-	return createCommand("pantheon-agents config").version(version).description("Configure agent for pantheon project").argument("<name>", "The name of the agent.").argument("<role>", "The role of the agent.").argument("<project-id>", "The project id of the agent.").option("--skills <skills>", "The skills of the agent. Multiple values are separated by comma.", (val) => val.split(",").map((s) => s.trim()).filter((s) => s !== ""), []).option("--execute-agent <agent>", "The execute agent of the agent.", "codex").option("--root-branch-id <branchId>", "The root branch id of the agent. Default to project root branch id.").option("--prototype-url <url>", "Role and skill definitions repo.", "https://github.com/pingcap-inc/pantheon-agents").option("--no-bootstrap", "Prevent bootstrap base branch for agent. Use the root branch as base branch.").action(async function() {
+	return createCommand("config").version(version).description("Configure agent for pantheon project").argument("<name>", "The name of the agent.").argument("<role>", "The role of the agent.").argument("<project-id>", "The project id of the agent.").option("--skills <skills>", "The skills of the agent. Multiple values are separated by comma.", (val) => val.split(",").map((s) => s.trim()).filter((s) => s !== ""), []).option("--execute-agent <agent>", "The execute agent of the agent.", "codex").option("--root-branch-id <branchId>", "The root branch id of the agent. Default to project root branch id.").option("--prototype-url <url>", "Role and skill definitions repo.", "https://github.com/pingcap-inc/pantheon-agents").option("--no-bootstrap", "Prevent bootstrap base branch for agent. Use the root branch as base branch.").action(async function() {
 		const [name, role, projectId] = this.args;
+		const options = this.opts();
+		const requiredEnvVars = ["DATABASE_URL"];
+		if (options.bootstrap || !options.rootBranchId) requiredEnvVars.push("PANTHEON_API_KEY");
+		if (!ensureEnv(requiredEnvVars)) return;
 		await configAgent(name, {
 			role,
 			projectId,
-			...this.opts()
+			...options
 		});
 	});
 }
@@ -10130,8 +10479,9 @@ function createConfigAgentCommand(version) {
 //#endregion
 //#region src/cli/commands/delete-task.ts
 function createDeleteTaskCommand(version) {
-	return createCommand("pantheon-agents delete-task").version(version).description("Delete a task for an agent").argument("<name>", "The name of the agent.").argument("<task-id>", "The id of the task.").action(async function() {
+	return createCommand("delete-task").version(version).description("Delete a task for an agent").argument("<name>", "The name of the agent.").argument("<task-id>", "The id of the task.").action(async function() {
 		const [name, taskId] = this.args;
+		if (!ensureEnv(["DATABASE_URL"])) return;
 		const rl = readline.createInterface({
 			input: process$1.stdin,
 			output: process$1.stdout
@@ -10139,16 +10489,19 @@ function createDeleteTaskCommand(version) {
 		try {
 			if ((await rl.question(`Type the task id (${taskId}) to confirm deletion: `)).trim() !== taskId) {
 				console.error("Confirmation failed. Task id did not match.");
-				process$1.exit(1);
+				process$1.exitCode = 1;
+				return;
 			}
 			if ((await rl.question("Type DELETE to permanently remove this task: ")).trim() !== "DELETE") {
 				console.error("Confirmation failed. Aborting deletion.");
-				process$1.exit(1);
+				process$1.exitCode = 1;
+				return;
 			}
 			const deletedTask = await deleteTask(name, taskId);
 			if (!deletedTask) {
 				console.error(`Task ${taskId} not found for agent ${name}.`);
-				process$1.exit(1);
+				process$1.exitCode = 1;
+				return;
 			}
 			console.log(`Deleted task ${taskId} for agent ${name}. Status was ${deletedTask.status}.`);
 		} finally {
@@ -10177,33 +10530,31 @@ function parseUniqueCommaList(value) {
 //#endregion
 //#region src/cli/commands/reconfig.ts
 function createReconfigAgentCommand(version) {
-	return createCommand("pantheon-agents reconfig").version(version).description("Re-bootstrap an existing agent configuration for a project").argument("<name>", "The name of the agent.").argument("<project-id>", "The project id of the agent.").option("--role <role>", "Override role for the agent.").option("--skills <skills>", "Override skills for the agent (comma-separated, replaces existing list).", parseUniqueCommaList).action(async function() {
+	return createCommand("reconfig").version(version).description("Re-bootstrap an existing agent configuration for a project").argument("<name>", "The name of the agent.").argument("<project-id>", "The project id of the agent.").option("--role <role>", "Override role for the agent.").option("--skills <skills>", "Override skills for the agent (comma-separated, replaces existing list).", parseUniqueCommaList).action(async function() {
 		const [name, projectId] = this.args;
 		const options = this.opts();
+		if (!ensureEnv(["DATABASE_URL", "PANTHEON_API_KEY"])) return;
 		const resolvedRole = options.role?.trim();
 		if (options.role != null && !resolvedRole) {
 			console.error("--role must be non-empty.");
-			process$1.exit(1);
-		}
-		try {
-			await reconfigAgent(name, {
-				projectId,
-				role: resolvedRole,
-				skills: options.skills
-			});
-		} catch (error) {
-			console.error(getErrorMessage(error));
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
+		await reconfigAgent(name, {
+			projectId,
+			role: resolvedRole,
+			skills: options.skills
+		});
 	});
 }
 
 //#endregion
 //#region src/cli/commands/run.ts
 function createRunAgentCommand(version) {
-	return createCommand("pantheon-agents run").version(version).description("Start a pantheon agents").argument("<name>", "The name of the agent.").option("--data-dir [dir]", "Data directory.", expandTilde("~/.pantheon-agents")).option("--mcp-port", "The port of the MCP server. Defaults to a random port.").option("--loop-interval <seconds>", "The interval of the loop in seconds. Defaults to 5.", (val) => parseInt(val, 10), 5).action(async function() {
+	return createCommand("run").version(version).description("Start a pantheon agent").argument("<name>", "The name of the agent.").option("--data-dir [dir]", "Data directory.", expandTilde("~/.pantheon-agents")).option("--loop-interval <seconds>", "The interval of the loop in seconds. Defaults to 5.", (val) => parseInt(val, 10), 5).action(async function() {
 		const [name] = this.args;
 		const options = this.opts();
+		if (!ensureEnv(["DATABASE_URL", "PANTHEON_API_KEY"])) return;
 		const logFileTransport = transport({
 			target: "pino-roll",
 			options: {
@@ -21793,6 +22144,141 @@ function taskToDTO(agent, task) {
 		error: task.status === "failed" ? task.error : null
 	};
 }
+function agentConfigToDTO(config) {
+	return {
+		agent: config.agent,
+		project_id: config.project_id,
+		base_branch_id: config.base_branch_id,
+		role: config.role,
+		skills: config.skills,
+		prototype_url: config.prototype_url,
+		execute_agent: config.execute_agent
+	};
+}
+
+//#endregion
+//#region src/server/agent-config.ts
+function assertPantheonApiKeyConfigured() {
+	if (!process.env.PANTHEON_API_KEY?.trim()) throw new ApiError({
+		status: 503,
+		code: "pantheon_api_key_missing",
+		message: "Missing PANTHEON_API_KEY. This endpoint requires Pantheon API access."
+	});
+}
+async function getBranchOutputOrThrow(options) {
+	let state;
+	try {
+		state = await options.getPantheonBranchFn({
+			projectId: options.projectId,
+			branchId: options.branchId,
+			getOutputIfFinished: true,
+			manifestingAsSucceed: true
+		});
+	} catch (error) {
+		throw new ApiError({
+			status: 502,
+			code: "pantheon_api_error",
+			message: `Failed to fetch Pantheon branch output for ${options.branchId}.`,
+			details: {
+				project_id: options.projectId,
+				branch_id: options.branchId,
+				error: getErrorMessage(error)
+			}
+		});
+	}
+	if (state.state === "succeed") return state.output ?? "";
+	if (state.state === "failed") throw new ApiError({
+		status: 502,
+		code: "pantheon_branch_failed",
+		message: `Pantheon branch ${options.branchId} failed.`,
+		details: {
+			project_id: options.projectId,
+			branch_id: options.branchId,
+			error: state.error
+		}
+	});
+	throw new ApiError({
+		status: 502,
+		code: "pantheon_branch_not_ready",
+		message: `Pantheon branch ${options.branchId} is not finished yet.`,
+		details: {
+			project_id: options.projectId,
+			branch_id: options.branchId
+		}
+	});
+}
+async function getAgentConfigWithBootstrapOutput(options) {
+	assertPantheonApiKeyConfigured();
+	const config = await options.provider.getAgentConfig(options.projectId);
+	if (!config) throw new ApiError({
+		status: 404,
+		code: "config_not_found",
+		message: `No config found for agent ${options.agent} and project ${options.projectId}.`
+	});
+	const bootstrapOutput = await getBranchOutputOrThrow({
+		projectId: config.project_id,
+		branchId: config.base_branch_id,
+		getPantheonBranchFn: options.getPantheonBranchFn ?? getPantheonBranch
+	});
+	return {
+		config: agentConfigToDTO(config),
+		bootstrap_output: bootstrapOutput
+	};
+}
+async function reconfigAgentConfigWithBootstrapOutput(options) {
+	assertPantheonApiKeyConfigured();
+	const getPantheonBranchFn = options.getPantheonBranchFn ?? getPantheonBranch;
+	const wrappedGetPantheonBranch = (args) => getPantheonBranchFn({
+		...args,
+		manifestingAsSucceed: true
+	});
+	let result;
+	try {
+		result = await reconfigAgentWithDeps(options.agent, options.reconfig, {
+			provider: options.provider,
+			executeOnPantheonFn: options.executeOnPantheonFn ?? executeOnPantheon,
+			getPantheonBranchFn: wrappedGetPantheonBranch,
+			sleep: options.sleep,
+			pollIntervalMs: options.pollIntervalMs,
+			maxRetries: options.maxRetries
+		});
+	} catch (error) {
+		if (error instanceof ApiError) throw error;
+		const message = getErrorMessage(error);
+		if (message.startsWith("No config found for agent ")) throw new ApiError({
+			status: 404,
+			code: "config_not_found",
+			message
+		});
+		if (message === "--role must be non-empty.") throw new ApiError({
+			status: 400,
+			code: "validation_error",
+			message
+		});
+		if (message.startsWith("Bootstrap failed:")) throw new ApiError({
+			status: 502,
+			code: "bootstrap_failed",
+			message
+		});
+		throw new ApiError({
+			status: 502,
+			code: "reconfig_failed",
+			message,
+			details: { error: message }
+		});
+	}
+	const updated = await options.provider.getAgentConfig(result.previousConfig.project_id);
+	if (!updated) throw new ApiError({
+		status: 500,
+		code: "config_update_lost",
+		message: "Config disappeared after reconfig update."
+	});
+	return {
+		previous_config: agentConfigToDTO(result.previousConfig),
+		config: agentConfigToDTO(updated),
+		bootstrap_output: result.bootstrapOutput
+	};
+}
 
 //#endregion
 //#region src/server/api.ts
@@ -21831,6 +22317,10 @@ const createTaskBodySchema = z$1.object({
 	project_id: z$1.string().min(1),
 	task: z$1.string().min(1)
 });
+const reconfigBodySchema = z$1.object({
+	role: z$1.string().trim().min(1).optional(),
+	skills: z$1.array(z$1.string().trim().min(1)).optional()
+});
 function getAgentParam(value) {
 	if (typeof value !== "string" || value.trim().length === 0) throw new ApiError({
 		status: 400,
@@ -21839,6 +22329,14 @@ function getAgentParam(value) {
 	});
 	return value;
 }
+function getProjectIdParam(value) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new ApiError({
+		status: 400,
+		code: "validation_error",
+		message: "Invalid project_id parameter."
+	});
+	return value;
+}
 function getTaskIdParam(value) {
 	if (typeof value !== "string" || value.trim().length === 0) throw new ApiError({
 		status: 400,
@@ -21854,6 +22352,31 @@ function createApiRouter(options) {
 		const agents = await new TaskListTidbProvider("server", logger, { db }).listAgentNames();
 		res.json({ agents });
 	}));
+	router.get("/agents/:agent/configs/:project_id", asyncHandler(async (req, res) => {
+		const agent = getAgentParam(req.params.agent);
+		const result = await getAgentConfigWithBootstrapOutput({
+			agent,
+			projectId: getProjectIdParam(req.params.project_id),
+			provider: new TaskListTidbProvider(agent, logger, { db })
+		});
+		res.json(result);
+	}));
+	router.post("/agents/:agent/configs/:project_id/reconfig", asyncHandler(async (req, res) => {
+		const agent = getAgentParam(req.params.agent);
+		const projectId = getProjectIdParam(req.params.project_id);
+		const body = reconfigBodySchema.parse(req.body);
+		const provider = new TaskListTidbProvider(agent, logger, { db });
+		const result = await reconfigAgentConfigWithBootstrapOutput({
+			agent,
+			reconfig: {
+				projectId,
+				role: body.role,
+				skills: body.skills
+			},
+			provider
+		});
+		res.json(result);
+	}));
 	router.get("/agents/:agent/tasks", asyncHandler(async (req, res) => {
 		const agent = getAgentParam(req.params.agent);
 		const query = listTasksQuerySchema.parse(req.query);
@@ -31721,6 +32244,51 @@ function createAgentsMcpServer(options) {
 			structuredContent: { deleted: true }
 		};
 	});
+	server.registerTool("configs.get", {
+		description: "Get an agent's config for a project, including the bootstrap branch output.",
+		inputSchema: {
+			agent: z$1.string().min(1),
+			project_id: z$1.string().min(1)
+		}
+	}, async ({ agent, project_id }) => {
+		return {
+			content: [{
+				type: "text",
+				text: "OK"
+			}],
+			structuredContent: await getAgentConfigWithBootstrapOutput({
+				agent,
+				projectId: project_id,
+				provider: new TaskListTidbProvider(agent, options.logger, { db: options.db })
+			})
+		};
+	});
+	server.registerTool("configs.reconfig", {
+		description: "Re-bootstrap an existing agent configuration for a project (like `pantheon-agents reconfig`).",
+		inputSchema: {
+			agent: z$1.string().min(1),
+			project_id: z$1.string().min(1),
+			role: z$1.string().trim().min(1).optional(),
+			skills: z$1.array(z$1.string().trim().min(1)).optional()
+		}
+	}, async ({ agent, project_id, role, skills }) => {
+		const provider = new TaskListTidbProvider(agent, options.logger, { db: options.db });
+		return {
+			content: [{
+				type: "text",
+				text: "OK"
+			}],
+			structuredContent: await reconfigAgentConfigWithBootstrapOutput({
+				agent,
+				reconfig: {
+					projectId: project_id,
+					role,
+					skills
+				},
+				provider
+			})
+		};
+	});
 	return server;
 }
 
@@ -31831,11 +32399,13 @@ async function startAgentsServer(options, logger, overrides = {}) {
 //#endregion
 //#region src/cli/commands/server.ts
 function createServerCommand(version) {
-	return createCommand("pantheon-agents server").version(version).description("Start the task HTTP API + MCP server").option("--host <host>", "Bind host. Defaults to 127.0.0.1.", "127.0.0.1").option("--port <port>", "Bind port. Defaults to 8000.", (v) => parseInt(v, 10), 8e3).option("--base-path <path>", "Mount base path prefix. Defaults to /.", "/").option("--token <token>", "Bearer token for API auth. Defaults to env PANTHEON_AGENTS_API_TOKEN.").option("--no-auth", "Disable auth (NOT recommended).").action(async function() {
+	return createCommand("server").version(version).description("Start the task HTTP API + MCP server").option("--host <host>", "Bind host. Defaults to 127.0.0.1.", "127.0.0.1").option("--port <port>", "Bind port. Defaults to 8000.", (v) => parseInt(v, 10), 8e3).option("--base-path <path>", "Mount base path prefix. Defaults to /.", "/").option("--token <token>", "Bearer token for API auth. Defaults to env PANTHEON_AGENTS_API_TOKEN.").option("--no-auth", "Disable auth (NOT recommended).").action(async function() {
 		const options = this.opts();
+		if (!ensureEnv(["DATABASE_URL"])) return;
 		if (!Number.isInteger(options.port) || options.port <= 0) {
 			console.error("Invalid --port value. Must be a positive integer.");
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
 		const logger = pino({
 			timestamp: pino.stdTimeFunctions.isoTime,
@@ -31858,14 +32428,16 @@ function createServerCommand(version) {
 //#endregion
 //#region src/cli/commands/show-config.ts
 function createShowConfigCommand(version) {
-	return createCommand("pantheon-agents show-config").version(version).description("Show agent config for a project").argument("<name>", "The name of the agent.").argument("[project-id]", "The project id.").option("--json", "Output config as JSON.").action(async function() {
+	return createCommand("show-config").version(version).description("Show agent config for a project").argument("<name>", "The name of the agent.").argument("[project-id]", "The project id.").option("--json", "Output config as JSON.").action(async function() {
 		const [name, projectId] = this.args;
 		const options = this.opts();
+		if (!ensureEnv(["DATABASE_URL"])) return;
 		if (projectId) {
 			const config = await showAgentConfig(name, projectId);
 			if (!config) {
 				console.error(`No config found for agent ${name} and project ${projectId}.`);
-				process$1.exit(1);
+				process$1.exitCode = 1;
+				return;
 			}
 			if (options.json) {
 				console.log(JSON.stringify(config, null, 2));
@@ -31885,7 +32457,8 @@ function createShowConfigCommand(version) {
 		const configs = await showAgentConfigs(name);
 		if (!configs.length) {
 			console.error(`No configs found for agent ${name}.`);
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
 		if (options.json) {
 			console.log(JSON.stringify(configs, null, 2));
@@ -31922,46 +32495,50 @@ const orderDirections = ["asc", "desc"];
 //#endregion
 //#region src/cli/commands/show-tasks.ts
 function createShowTasksCommand(version) {
-	return createCommand("pantheon-agents show-tasks").version(version).description("Show tasks for an agent").argument("[name]", "The name of the agent.").option("--agents <names>", "Comma-separated agent names to query in one call.", parseCommaList, []).option("--all", "Show tasks for all agents.").option("--status <status>", "Filter tasks by status. Multiple values are separated by comma.", parseCommaList, []).option("--order-by <field>", "Order by queued_at, started_at, or ended_at.", "queued_at").option("--order-direction <direction>", "Order direction: asc or desc.", "desc").option("--limit <number>", "Limit the number of tasks shown.", (val) => parseInt(val, 10)).option("--max-task-length <number>", "Maximum task length for table output.", (val) => parseInt(val, 10), 120).option("--full-task", "Do not truncate task text in output.").option("--concise", "Output concise one-line entries.", true).option("--no-color", "Disable colored output.").option("--json", "Output tasks as JSON.").action(async function() {
+	return createCommand("show-tasks").version(version).description("Show tasks for an agent").argument("[name]", "The name of the agent.").option("--agents <names>", "Comma-separated agent names to query in one call.", parseCommaList, []).option("--all", "Show tasks for all agents.").option("--status <status>", "Filter tasks by status. Multiple values are separated by comma.", parseCommaList, []).option("--order-by <field>", "Order by queued_at, started_at, or ended_at.", "queued_at").option("--order-direction <direction>", "Order direction: asc or desc.", "desc").option("--limit <number>", "Limit the number of tasks shown.", (val) => parseInt(val, 10)).option("--max-task-length <number>", "Maximum task length for table output.", (val) => parseInt(val, 10), 120).option("--full-task", "Do not truncate task text in output.").option("--no-concise", "Disable concise one-line entries.").option("--no-color", "Disable colored output.").option("--json", "Output tasks as JSON.").action(async function() {
 		const [name] = this.args;
 		const options = this.opts();
+		if (!ensureEnv(["DATABASE_URL"])) return;
 		const agentNames = /* @__PURE__ */ new Set();
 		if (name) agentNames.add(name);
 		options.agents.forEach((agent) => agentNames.add(agent));
 		if (options.all && agentNames.size > 0) {
 			console.error("Use either a specific agent name or --all, not both.");
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
 		if (!options.all && agentNames.size === 0) {
 			console.error("Provide an agent name, --agents, or --all.");
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
 		const invalidStatuses = options.status.filter((status) => !taskStatuses.includes(status));
 		if (invalidStatuses.length > 0) {
 			console.error(`Invalid status values: ${invalidStatuses.join(", ")}. Allowed: ${taskStatuses.join(", ")}.`);
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
 		if (!orderByFields.includes(options.orderBy)) {
 			console.error(`Invalid order-by value: ${options.orderBy}. Allowed: ${orderByFields.join(", ")}.`);
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
 		if (!orderDirections.includes(options.orderDirection)) {
 			console.error(`Invalid order-direction value: ${options.orderDirection}. Allowed: ${orderDirections.join(", ")}.`);
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
 		if (options.limit != null && Number.isNaN(options.limit)) {
 			console.error("Invalid limit value. Must be a number.");
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
 		if (Number.isNaN(options.maxTaskLength) || options.maxTaskLength <= 0) {
 			console.error("Invalid max-task-length value. Must be a positive number.");
-			process$1.exit(1);
+			process$1.exitCode = 1;
+			return;
 		}
 		if (options.fullTask && options.maxTaskLength) options.maxTaskLength = Number.POSITIVE_INFINITY;
-		if (options.json && options.concise) {
-			console.error("Use either --json or --concise, not both.");
-			process$1.exit(1);
-		}
 		const limitedTasks = await showTasksForAgents({
 			agents: Array.from(agentNames),
 			allAgents: options.all,
@@ -31998,36 +32575,1619 @@ function createShowTasksCommand(version) {
 }
 
 //#endregion
-//#region src/cli/utils/env.ts
-function warnIfMissingEnv(keys) {
-	for (const key of keys) if (!process.env[key]) console.error(`${key} environment variable is not set.`);
+//#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)).addCommand(createWatchCommand(version$1));
+async function main() {
+	if (process$1.argv.length <= 2) {
+		program.outputHelp();
+		return;
+	}
+	await program.parseAsync(process$1.argv);
+}
+try {
+	await main();
+} catch (error) {
+	console.error(getErrorMessage(error));
+	process$1.exitCode = 1;
 }
-
-//#endregion
-//#region src/cli/index.ts
-warnIfMissingEnv(["PANTHEON_API_KEY", "DATABASE_URL"]);
-const commands = {
-	"add-task": createAddTaskCommand(version$1),
-	config: createConfigAgentCommand(version$1),
-	"delete-task": createDeleteTaskCommand(version$1),
-	reconfig: createReconfigAgentCommand(version$1),
-	run: createRunAgentCommand(version$1),
-	server: createServerCommand(version$1),
-	"show-config": createShowConfigCommand(version$1),
-	"show-tasks": createShowTasksCommand(version$1)
-};
-function printCommandHelpAndExit(command) {
-	console.error(`Invalid command: ${command}. Supported commands: ${Object.keys(commands).join(", ")}.`);
-	console.error("  Run pantheon-agents help <command> for more information.");
-	process$1.exit(1);
-}
-if (process$1.argv[2] === "help") {
-	const command = process$1.argv[3];
-	if (command in commands) commands[command].help({ error: false });
-	else printCommandHelpAndExit(command);
-}
-if (!commands[process$1.argv[2]]) printCommandHelpAndExit(process$1.argv[2]);
-commands[process$1.argv[2]].parse(process$1.argv.slice(3), { from: "user" });
 
 //#endregion
 export {  };