@pantheon.ai/agents 0.0.15 → 0.0.17

package/dist/index.js

@@ -16,6 +16,7 @@ import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
 import blessed from "reblessed";
 import { inspect } from "node:util";
+import { parse } from "shell-quote";
 
 //#region ../../node_modules/dotenv/package.json
 var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -394,7 +395,7 @@ var require_cli_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 
 //#endregion
 //#region package.json
-var version$1 = "0.0.15";
+var version$1 = "0.0.17";
 
 //#endregion
 //#region src/schemas/task-list.ts
@@ -2344,7 +2345,7 @@ const _parse$1 = (_Err) => (schema, value, _ctx, _params) => {
 	}
 	return result.value;
 };
-const parse$1 = /* @__PURE__ */ _parse$1($ZodRealError);
+const parse$2 = /* @__PURE__ */ _parse$1($ZodRealError);
 const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
 	const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
 	let result = schema._zod.run({
@@ -5521,7 +5522,7 @@ const ZodRealError = $constructor("ZodError", initializer, { Parent: Error });
 
 //#endregion
 //#region ../../node_modules/zod/v4/classic/parse.js
-const parse = /* @__PURE__ */ _parse$1(ZodRealError);
+const parse$1 = /* @__PURE__ */ _parse$1(ZodRealError);
 const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 const safeParse$1 = /* @__PURE__ */ _safeParse(ZodRealError);
 const safeParseAsync$1 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -5560,7 +5561,7 @@ const ZodType$1 = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 		reg.add(inst, meta);
 		return inst;
 	});
-	inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+	inst.parse = (data, params) => parse$1(inst, data, params, { callee: inst.parse });
 	inst.safeParse = (data, params) => safeParse$1(inst, data, params);
 	inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
 	inst.safeParseAsync = async (data, params) => safeParseAsync$1(inst, data, params);
@@ -17342,32 +17343,40 @@ async function consumeOpaqueSseStream(options) {
 	};
 }
 var WatchStepAggregator = class {
-	maxLeadingTextChars;
-	maxLeadingReasoningChars;
 	maxLogLines;
 	maxWarnings;
-	leadingText = "";
-	leadingReasoning = "";
 	toolActions = /* @__PURE__ */ new Map();
+	timeline = [];
 	logLines = [];
+	todoItems = [];
 	warnings = [];
+	warningItems = [];
 	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);
+		if (Number.isFinite(this.maxLogLines) && this.maxLogLines > 0 && this.logLines.length > this.maxLogLines) this.logLines.splice(0, this.logLines.length - this.maxLogLines);
 	}
 	pushWarning(message) {
 		if (!message) return;
+		const order = this.orderCounter++;
 		this.warnings.push(message);
+		this.warningItems.push({
+			message,
+			order
+		});
+		this.timeline.push({
+			kind: "warning",
+			message,
+			order
+		});
 		if (this.warnings.length > this.maxWarnings) this.warnings.splice(0, this.warnings.length - this.maxWarnings);
+		if (this.warningItems.length > this.maxWarnings) this.warningItems.splice(0, this.warningItems.length - this.maxWarnings);
 	}
 	pushCommandExecutionOutput(output) {
 		const out = output;
@@ -17377,6 +17386,31 @@ var WatchStepAggregator = class {
 		if (trimmed) trimmed.split("\n").forEach((line) => this.pushLog(line));
 		if (exitCode != null && exitCode !== 0) this.pushLog(`exit_code=${exitCode}`);
 	}
+	setTodoItems(items) {
+		if (!Array.isArray(items)) return;
+		const normalized = [];
+		for (const item of items) {
+			if (typeof item !== "object" || item === null) continue;
+			const text = typeof item.text === "string" ? item.text : "";
+			const completed = Boolean(item.completed);
+			if (!text) continue;
+			normalized.push({
+				text,
+				completed
+			});
+		}
+		this.todoItems = normalized;
+	}
+	pushTimelineText(kind, delta) {
+		if (!delta) return this.orderCounter;
+		const order = this.orderCounter++;
+		this.timeline.push({
+			kind,
+			order,
+			text: delta
+		});
+		return order;
+	}
 	getOrCreateToolAction(toolCallId) {
 		const existing = this.toolActions.get(toolCallId);
 		if (existing) return existing;
@@ -17386,6 +17420,11 @@ var WatchStepAggregator = class {
 			_order: this.orderCounter++
 		};
 		this.toolActions.set(toolCallId, created);
+		this.timeline.push({
+			kind: "tool",
+			order: created._order,
+			toolCallId
+		});
 		return created;
 	}
 	pushUiChunk(chunk) {
@@ -17396,19 +17435,13 @@ var WatchStepAggregator = class {
 			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);
-				}
+				this.pushTimelineText("message", delta);
 				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);
-				}
+				this.pushTimelineText("reasoning", delta);
 				return;
 			}
 			case "tool-input-start": {
@@ -17476,6 +17509,11 @@ var WatchStepAggregator = class {
 				this.pushLog(`! unknown: ${reason}`);
 				return;
 			}
+			case "data-agent-event": {
+				const data = chunk.data;
+				if (data?.kind === "codex.todo_list") this.setTodoItems(data.items);
+				return;
+			}
 			default: return;
 		}
 	}
@@ -17483,13 +17521,16 @@ var WatchStepAggregator = class {
 		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,
+			toolActions: Array.from(this.toolActions.values()).sort((a, b) => a._order - b._order).map(({ _order, ...rest }) => ({
+				...rest,
+				order: _order
+			})),
+			timeline: this.timeline.map((item) => ({ ...item })),
 			logLines: [...this.logLines],
+			todoItems: this.todoItems.map((item) => ({ ...item })),
 			warnings: [...this.warnings],
+			warningItems: this.warningItems.map((item) => ({ ...item })),
 			unknownEventCount: this.unknownEventCount
 		};
 	}
@@ -18099,11 +18140,11 @@ function createLlmExplainCommand(version) {
 				projectId: task.project_id,
 				branchId: task.branch_id
 			});
-			if (!branch.branch.latest_snap?.event_stream_id) {
+			if (!branch.branch?.latest_snap?.event_stream_id) {
 				console.error(`Branch ${task.branch_id} has no latest snap.`);
 				process$1.exit(1);
 			}
-			const stream = await getRawStream(branch.branch.latest_snap.event_stream_id);
+			const stream = await getRawStream(branch.branch?.latest_snap.event_stream_id);
 			const text = await llmExplain(task.task, stream, {
 				timeout: 3e3,
 				characters
@@ -21138,7 +21179,7 @@ const ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst.def = def;
 	inst.type = def.type;
-	inst.parse = (data, params) => parse$1(inst, data, params, { callee: inst.parse });
+	inst.parse = (data, params) => parse$2(inst, data, params, { callee: inst.parse });
 	inst.safeParse = (data, params) => safeParse$2(inst, data, params);
 	inst.parseAsync = async (data, params) => parseAsync$1(inst, data, params, { callee: inst.parseAsync });
 	inst.safeParseAsync = async (data, params) => safeParseAsync$2(inst, data, params);
@@ -31886,6 +31927,52 @@ function createClaudeCodeNormalizer(options = {}) {
 		});
 		return out;
 	}
+	function formatToolResultOutput(content, toolUseResult) {
+		if (toolUseResult == null) return content ?? null;
+		if (content == null) return toolUseResult;
+		if (typeof content === "string" && content.length === 0) return toolUseResult;
+		return {
+			content,
+			tool_use_result: toolUseResult
+		};
+	}
+	function getToolResultErrorText(content, toolUseResult) {
+		if (typeof content === "string" && content.trim().length > 0) return content;
+		if (isRecord(toolUseResult) && typeof toolUseResult.stderr === "string") {
+			const stderr = toolUseResult.stderr.trim();
+			if (stderr.length > 0) return stderr;
+		}
+		try {
+			if (toolUseResult != null) return JSON.stringify(toolUseResult);
+		} catch {}
+		return "Tool execution failed";
+	}
+	function handleUserMessage(message, toolUseResult) {
+		const blocks = Array.isArray(message.content) ? message.content : [];
+		const out = [];
+		blocks.forEach((block, index) => {
+			if (!isRecord(block) || block.type !== "tool_result") return;
+			const toolCallId = typeof block.tool_use_id === "string" ? block.tool_use_id : `claude-tool-result-${index}`;
+			const content = block.content;
+			const interrupted = isRecord(toolUseResult) && toolUseResult.interrupted === true;
+			if (block.is_error === true || interrupted) {
+				out.push({
+					type: "tool-output-error",
+					toolCallId,
+					errorText: getToolResultErrorText(content, toolUseResult),
+					dynamic: true
+				});
+				return;
+			}
+			out.push({
+				type: "tool-output-available",
+				toolCallId,
+				output: formatToolResultOutput(content, toolUseResult),
+				dynamic: true
+			});
+		});
+		return out;
+	}
 	function push(chunk) {
 		const parsed = topLevelSchema.safeParse(chunk);
 		if (!parsed.success) return {
@@ -31917,7 +32004,6 @@ function createClaudeCodeNormalizer(options = {}) {
 				};
 			}
 			case "stream_event": {
-				sawStreamEvents = true;
 				const event = streamEventSchema.safeParse(msg.event);
 				if (!event.success) return {
 					recognized: false,
@@ -31939,6 +32025,17 @@ function createClaudeCodeNormalizer(options = {}) {
 					chunks: handleAssistantMessage(message)
 				};
 			}
+			case "user": {
+				const message = msg.message;
+				if (!isRecord(message)) return {
+					recognized: false,
+					chunks: []
+				};
+				return {
+					recognized: true,
+					chunks: handleUserMessage(message, msg.tool_use_result)
+				};
+			}
 			case "result": return {
 				recognized: true,
 				chunks: maybeMeta({
@@ -32085,36 +32182,150 @@ function tryExtractBashCommand(command) {
 	}
 	return rest.trim();
 }
-function formatCommandExecutionDisplayCommand(command) {
+function normalizeCommand(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}`;
+function splitCommandLines(command) {
+	return command.replaceAll("\r\n", "\n").split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function stripCommentPrefix(line) {
+	const trimmed = line.trim();
+	if (trimmed.startsWith("//")) return trimmed.slice(2).trimStart();
+	return trimmed;
+}
+function commandBasename(value) {
+	const lastSlash = value.lastIndexOf("/");
+	return lastSlash === -1 ? value : value.slice(lastSlash + 1);
+}
+function parseShellEntries(line) {
+	try {
+		return parse(line);
+	} catch {
+		return;
+	}
+}
+function takeMainTokens(entries) {
+	const stopSet = new Set([
+		"|",
+		"||",
+		"&&",
+		";",
+		"|&",
+		";;",
+		"&",
+		"(",
+		")",
+		"<",
+		">",
+		">>",
+		">&",
+		"<("
+	]);
+	const out = [];
+	for (const entry of entries) {
+		if (typeof entry === "string") {
+			out.push(entry);
+			continue;
+		}
+		if ("op" in entry) {
+			if (stopSet.has(entry.op)) break;
+			continue;
+		}
+		if ("comment" in entry) break;
+	}
+	return out;
+}
+function pickLastNonOptionArg(tokens) {
+	const values = tokens.filter((token) => !token.startsWith("-"));
+	return values.length > 0 ? values[values.length - 1] : void 0;
+}
+function parseExploredItem(line) {
+	const entries = parseShellEntries(normalizeCommand(line));
+	if (!entries) return void 0;
+	const tokens = takeMainTokens(entries);
+	if (tokens.length === 0) return void 0;
+	const command = commandBasename(tokens[0] ?? "");
+	if (command === "rg") {
+		const args = tokens.slice(1);
+		if (args.includes("--files")) return {
+			kind: "list",
+			target: pickLastNonOptionArg(args)
+		};
+		const firstValueIndex = args.findIndex((token) => !token.startsWith("-"));
+		if (firstValueIndex === -1) return void 0;
+		const terms = args[firstValueIndex];
+		const file = args[firstValueIndex + 1];
+		if (!terms || !file) return void 0;
+		return {
+			kind: "search",
+			terms,
+			file
+		};
+	}
+	if (command === "ls") return {
+		kind: "list",
+		target: pickLastNonOptionArg(tokens.slice(1))
+	};
+	if (command === "sed" || command === "nl" || command === "cat") {
+		if (tokens.length < 2) return void 0;
+		const file = tokens[tokens.length - 1];
+		if (!file || file.startsWith("-")) return void 0;
+		return {
+			kind: "read",
+			file
+		};
+	}
+}
+function parseExploredItemsFromCommand(command) {
+	const rawLines = splitCommandLines(normalizeCommand(command));
+	const items = [];
+	for (const rawLine of rawLines) {
+		const line = stripCommentPrefix(rawLine);
+		if (!line) continue;
+		const item = parseExploredItem(normalizeCommand(line));
+		if (!item) return void 0;
+		items.push(item);
+	}
+	if (items.length === 0) return void 0;
+	return items;
+}
+function formatExploredItemsLines(items) {
+	const lines = ["Explored"];
+	for (const item of items) {
+		if (item.kind === "read") {
+			lines.push(`Read ${item.file}`);
+			continue;
+		}
+		if (item.kind === "list") {
+			lines.push(item.target ? `List ${item.target}` : "List");
+			continue;
+		}
+		lines.push(`Search ${item.terms} in ${item.file}`);
+	}
+	return lines;
+}
+function getExploredCommandLines(command) {
+	const explored = parseExploredItemsFromCommand(command);
+	if (!explored) return void 0;
+	return formatExploredItemsLines(explored);
+}
+function isExploredCommandExecution(command) {
+	return parseExploredItemsFromCommand(command) != null;
+}
+function formatCommandExecutionDisplayCommand(command) {
+	const exploredLines = getExploredCommandLines(command);
+	if (exploredLines) return exploredLines.join("\n");
+	return normalizeCommand(command);
 }
 
 //#endregion
 //#region src/cli/commands/watch.ts
 const PANTHEON_BASE_URL = "https://pantheon-ai.tidb.ai";
-const DEFAULT_SCREEN_GRID = {
-	cols: 3,
-	rows: 1
-};
-function parseScreenGrid(value) {
-	const match = value.trim().toLowerCase().match(/^(\d+)x(\d+)$/);
-	if (!match) throw new InvalidArgumentError("screen must be <cols>x<rows>, e.g. 3x1 or 5x4");
-	const cols = Number(match[1]);
-	const rows = Number(match[2]);
-	if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols <= 0 || rows <= 0) throw new InvalidArgumentError("screen requires positive integer cols/rows, e.g. 3x1");
-	return {
-		cols,
-		rows
-	};
+function parseListWidth(value) {
+	const width = Number(value);
+	if (!Number.isInteger(width) || width <= 0) throw new InvalidArgumentError("list-width requires a positive integer, e.g. 32");
+	return width;
 }
 function ensureEnvOrExit(keys) {
 	const missing = keys.filter((key) => !process.env[key]);
@@ -32122,33 +32333,6 @@ function ensureEnvOrExit(keys) {
 	for (const key of missing) console.error(`${key} environment variable is not set.`);
 	process.exit(1);
 }
-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();
@@ -32296,42 +32480,36 @@ function yellow(text, enabled) {
 function cyan(text, enabled) {
 	return sgrWrap(text, ANSI.cyan, enabled);
 }
+function dimGray(text, enabled) {
+	return sgrWrap(text, `${ANSI.dim}${ANSI.gray}`, 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 getCommandExecutionDisplayCommand(tool) {
+	const raw = getCommandExecutionRawCommand(tool);
+	if (!raw) return void 0;
+	return formatCommandExecutionDisplayCommand(raw) || void 0;
 }
-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 colorizeCommandProgram(display, style) {
+	const match = display.match(/^(\s*)(\S+)([\s\S]*)$/);
+	if (!match) return display;
+	const [, leading, program, rest] = match;
+	return `${leading}${cyan(program ?? "", style)}${rest ?? ""}`;
 }
-function getCommandExecutionDisplayCommand(tool) {
+function getCommandExecutionRawCommand(tool) {
 	const title = typeof tool.title === "string" ? tool.title : "";
 	const inputCommand = typeof tool.input?.command === "string" ? tool.input.command : "";
-	const raw = title || inputCommand;
-	if (!raw) return void 0;
-	return formatCommandExecutionDisplayCommand(raw) || void 0;
+	return title || inputCommand || void 0;
 }
 function formatToolLabel(tool, style) {
 	const name = tool.toolName ?? "<tool>";
 	if (name === "command_execution") {
+		const rawCommand = getCommandExecutionRawCommand(tool);
+		const exploredLines = rawCommand ? getExploredCommandLines(rawCommand) : void 0;
+		if (exploredLines && exploredLines.length > 1) return cyan(exploredLines[0] ?? "Explored", style);
 		const display = getCommandExecutionDisplayCommand(tool) ?? "(unknown command)";
-		return `${bold("$", style)} ${cyan(display, style)}`;
+		return `${bold("$", style)} ${colorizeCommandProgram(display, style)}`;
 	}
 	const renderedName = bold(name, style);
 	if (!tool.title) return renderedName;
@@ -32346,45 +32524,56 @@ function formatToolSummaryLine(tool, style) {
 		default: return `${yellow("…", style)} ${label} (${id})`;
 	}
 }
-function toDisplayLines(text) {
-	return text.replaceAll("\r\n", "\n").split("\n");
+function getToolStatus(value) {
+	if (value === "completed" || value === "failed") return value;
+	return "in_progress";
 }
-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;
+function combineToolStatuses(statuses) {
+	const normalized = statuses.map((status) => getToolStatus(status));
+	if (normalized.some((status) => status === "failed")) return "failed";
+	if (normalized.some((status) => status === "in_progress")) return "in_progress";
+	return "completed";
+}
+function formatToolStatusIcon(status, style) {
+	switch (getToolStatus(status)) {
+		case "completed": return green("✓", style);
+		case "failed": return red("✗", style);
+		default: return yellow("…", style);
+	}
+}
+function getExploredSubCommandLines(tool) {
+	if (tool.toolName !== "command_execution") return void 0;
+	const rawCommand = getCommandExecutionRawCommand(tool);
+	if (!rawCommand) return void 0;
+	const exploredLines = getExploredCommandLines(rawCommand);
+	if (!exploredLines || exploredLines.length <= 1) return void 0;
+	return exploredLines.slice(1);
+}
+function formatExploredSubCommandLine(line, style) {
+	if (line.startsWith("Search ")) {
+		const payload = line.slice(7);
+		const at = payload.lastIndexOf(" in ");
+		if (at !== -1) {
+			const terms = payload.slice(0, at);
+			const file = payload.slice(at + 4);
+			return `${cyan("Search", style)} ${terms} ${dimGray("in", style)} ${file}`;
 		}
-		lines.push(current);
-		current = "";
-		if (word.length <= width) current = word;
-		else pushLongWord(word);
+		return `${cyan("Search", style)} ${payload}`;
 	}
-	if (current) lines.push(current);
-	return lines;
+	if (line.startsWith("Read ")) return `${cyan("Read", style)} ${line.slice(5)}`;
+	if (line === "List") return cyan("List", style);
+	if (line.startsWith("List ")) return `${cyan("List", style)} ${line.slice(5)}`;
+	return line;
+}
+function toDisplayLines(text) {
+	return text.replaceAll("\r\n", "\n").split("\n");
 }
-function formatWrappedTextLines(text, options) {
-	const trimmed = text.trim();
-	if (!trimmed) return [];
-	return trimLinesWithEllipsis(wrapCollapsedWhitespaceToWidth(trimmed, Math.max(10, options.widthHint)), options.maxLines).map((line) => options.formatValue ? options.formatValue(line) : line);
+function wrapRawLineToWidth(line, width) {
+	if (width <= 0) return [line];
+	if (line.length === 0) return [""];
+	const out = [];
+	for (let i = 0; i < line.length; i += width) out.push(line.slice(i, i + width));
+	return out;
 }
 function trimLinesWithEllipsis(lines, maxLines) {
 	if (maxLines <= 0) return [];
@@ -32395,14 +32584,34 @@ function trimLinesWithEllipsis(lines, maxLines) {
 	kept[lastIndex] = last ? `${last}…` : "…";
 	return kept;
 }
+function trimCommandOutputTopBottom(lines) {
+	if (lines.length <= 4) return lines;
+	const hidden = lines.length - 4;
+	return [
+		lines[0],
+		lines[1],
+		`… +${hidden} lines`,
+		lines[lines.length - 2],
+		lines[lines.length - 1]
+	];
+}
 function formatToolResultPreviewLines(tool, options) {
 	if (tool.status === "in_progress") return [];
 	if (options.maxLines <= 0) return [];
-	if (tool.status === "failed") return trimLinesWithEllipsis(toDisplayLines(tool.errorText ?? "(no error text)"), options.maxLines);
+	if (tool.toolName === "command_execution") {
+		const rawCommand = getCommandExecutionRawCommand(tool);
+		if (rawCommand && isExploredCommandExecution(rawCommand)) return [];
+	}
+	if (tool.status === "failed") {
+		const lines = toDisplayLines(tool.errorText ?? "(no error text)");
+		return trimLinesWithEllipsis(tool.toolName === "command_execution" ? trimCommandOutputTopBottom(lines) : lines, options.maxLines);
+	}
 	if (tool.output == null) return ["(none)"];
 	if (tool.toolName === "command_execution") {
 		const output = tool.output;
-		return trimLinesWithEllipsis(toDisplayLines((typeof output?.aggregated_output === "string" ? output.aggregated_output : "").trimEnd()), options.maxLines);
+		const allLines = toDisplayLines((typeof output?.aggregated_output === "string" ? output.aggregated_output : "").trimEnd());
+		if (!allLines.some((line) => line.length > 0)) return ["(none)"];
+		return trimLinesWithEllipsis(trimCommandOutputTopBottom(allLines), options.maxLines);
 	}
 	return trimLinesWithEllipsis(toDisplayLines(inspect(tool.output, {
 		depth: 6,
@@ -32442,8 +32651,59 @@ function clip(value, maxVisible) {
 	const sliced = sliceSgrByVisibleWidth(value, maxVisible - 1);
 	return `${sliced}…${sliced.includes("\x1B[") ? ANSI.reset : ""}`;
 }
+const TODO_PREVIEW_MAX_ITEMS = 3;
+const TODO_PREVIEW_MAX_PENDING = 2;
+function selectTodoPreviewItems(todoItems, options) {
+	const selected = [];
+	let pendingCount = 0;
+	for (let index = todoItems.length - 1; index >= 0; index--) {
+		const item = todoItems[index];
+		if (selected.length >= options.maxItems) break;
+		if (!item.completed && pendingCount >= options.maxPending) continue;
+		selected.push({
+			ordinal: index + 1,
+			item
+		});
+		if (!item.completed) pendingCount += 1;
+	}
+	selected.reverse();
+	return selected;
+}
+function wrapTodoItemLine(entry, widthHint) {
+	const { ordinal, item } = entry;
+	const normalizedText = item.text.trim().replaceAll(/\s+/g, " ") || "(empty)";
+	const prefix = `${ordinal}. ${item.completed ? "[x]" : "[ ]"} `;
+	return wrapRawLineToWidth(normalizedText, Math.max(1, widthHint - prefix.length)).map((chunk, chunkIndex) => chunkIndex === 0 ? `${prefix}${chunk}` : `${" ".repeat(prefix.length)}${chunk}`);
+}
+function trimLinesToHeight(lines, maxLines, style) {
+	if (maxLines <= 0) return [];
+	if (lines.length <= maxLines) return lines;
+	if (maxLines === 1) return [dimGray(`… +${lines.length} more lines`, style)];
+	const kept = lines.slice(0, maxLines - 1);
+	const hidden = lines.length - kept.length;
+	kept.push(dimGray(`… +${hidden} more lines`, style));
+	return kept;
+}
+function formatTodoPanelLines(options) {
+	if (options.todoItems.length === 0) return [];
+	const selectedEntries = options.fullView ? options.todoItems.map((item, index) => ({
+		ordinal: index + 1,
+		item
+	})) : selectTodoPreviewItems(options.todoItems, {
+		maxItems: TODO_PREVIEW_MAX_ITEMS,
+		maxPending: TODO_PREVIEW_MAX_PENDING
+	});
+	const lines = [bold("todos", options.style)];
+	selectedEntries.forEach((entry) => lines.push(...wrapTodoItemLine(entry, Math.max(1, options.widthHint))));
+	if (!options.fullView && selectedEntries.length < options.todoItems.length) {
+		const hidden = options.todoItems.length - selectedEntries.length;
+		lines.push(dimGray(`… +${hidden} more todos (t for full)`, options.style));
+	}
+	lines.push(dimGray("─".repeat(Math.max(1, options.widthHint)), options.style));
+	return lines;
+}
 function createWatchCommand(version) {
-	return createCommand("watch").version(version).description("Inspect task progress via 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("--screen <cols>x<rows>", "Pane grid in follow UI, e.g. 3x1 (default) or 5x4.", parseScreenGrid, DEFAULT_SCREEN_GRID).action(async function() {
+	return createCommand("watch").version(version).description("Inspect task progress via 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("--list-width <cols>", "Left task-list width in columns (default: 32).", parseListWidth, 32).action(async function() {
 		ensureEnvOrExit(["PANTHEON_API_KEY", "DATABASE_URL"]);
 		const options = this.opts();
 		if (options.tasks.length > 0 && options.agents.length > 0) {
@@ -32471,9 +32731,20 @@ function createWatchCommand(version) {
 			process.on("SIGINT", onSigInt);
 			const runtime = targets.map((target) => ({
 				target,
-				aggregator: new WatchStepAggregator({ maxLogLines: 120 }),
+				aggregator: new WatchStepAggregator({ maxLogLines: Number.POSITIVE_INFINITY }),
 				streamDone: false
 			}));
+			const logViewportByTaskId = /* @__PURE__ */ new Map();
+			function getLogViewport(taskId) {
+				const existing = logViewportByTaskId.get(taskId);
+				if (existing) return existing;
+				const created = {
+					autoFollow: true,
+					scrollOffset: 0
+				};
+				logViewportByTaskId.set(taskId, created);
+				return created;
+			}
 			async function startStream(rt, streamId) {
 				rt.streamAbort?.abort();
 				rt.streamAbort = new AbortController();
@@ -32509,7 +32780,7 @@ function createWatchCommand(version) {
 									normalizer = createAgentStreamNormalizer({
 										source: rt.source,
 										emitStartChunk: false,
-										includeMetaEvents: false,
+										includeMetaEvents: true,
 										unknownChunkPolicy: "emit"
 									});
 								}
@@ -32544,7 +32815,10 @@ function createWatchCommand(version) {
 						const nextStreamId = branch.latest_snap?.event_stream_id ?? void 0;
 						if (nextStreamId && nextStreamId !== rt.streamId) {
 							rt.streamId = nextStreamId;
-							rt.aggregator = new WatchStepAggregator({ maxLogLines: 120 });
+							rt.aggregator = new WatchStepAggregator({ maxLogLines: Number.POSITIVE_INFINITY });
+							const viewport = getLogViewport(rt.target.task.id);
+							viewport.autoFollow = true;
+							viewport.scrollOffset = 0;
 							await startStream(rt, nextStreamId);
 						}
 					} catch (error) {
@@ -32557,7 +32831,7 @@ function createWatchCommand(version) {
 				title: "pantheon-agents watch"
 			});
 			screen.key(["q", "C-c"], () => abortController.abort());
-			const footer = blessed.box({
+			const globalFooter = blessed.box({
 				parent: screen,
 				bottom: 0,
 				left: 0,
@@ -32567,108 +32841,325 @@ function createWatchCommand(version) {
 				content: "Ctrl+C to exit • q to quit",
 				style: { fg: "gray" }
 			});
-			const panes = runtime.map(() => blessed.box({
+			const taskListPane = blessed.list({
 				parent: screen,
 				top: 0,
 				left: 0,
 				height: "100%-1",
-				width: "100%",
+				width: options.listWidth,
+				border: "line",
+				tags: false,
+				wrap: false,
+				keys: false,
+				vi: false,
+				mouse: false,
+				style: {
+					border: { fg: "cyan" },
+					selected: {
+						fg: "black",
+						bg: "cyan"
+					},
+					item: { fg: "white" }
+				}
+			});
+			const rightPane = blessed.box({
+				parent: screen,
+				top: 0,
+				left: options.listWidth,
+				height: "100%-1",
+				width: `100%-${options.listWidth}`,
 				border: "line",
 				tags: false,
-				scrollable: false,
 				wrap: false,
 				style: { border: { fg: "gray" } }
-			}));
+			});
+			const rightHeader = blessed.box({
+				parent: rightPane,
+				top: 0,
+				left: 1,
+				height: 2,
+				width: "100%-2",
+				tags: false,
+				wrap: false
+			});
+			const rightBody = blessed.box({
+				parent: rightPane,
+				top: 2,
+				left: 1,
+				width: "100%-2",
+				height: 1,
+				tags: false,
+				wrap: false,
+				scrollable: false
+			});
+			const rightFooter = blessed.box({
+				parent: rightPane,
+				left: 1,
+				height: 1,
+				width: "100%-2",
+				tags: false,
+				wrap: false,
+				style: { fg: "gray" }
+			});
 			let lastGlobalError;
-			function layoutPanes(columns, rows) {
-				const n = panes.length;
-				if (n === 0) return {
-					visibleCount: 0,
-					hiddenCount: 0
-				};
-				const gridCols = Math.max(1, options.screen.cols);
-				const gridRows = Math.max(1, options.screen.rows);
-				const maxVisible = gridCols * gridRows;
-				const visibleCount = Math.min(n, maxVisible);
-				const paneAreaHeight = Math.max(1, rows - 1);
-				for (let i = 0; i < n; i++) {
-					const pane = panes[i];
-					if (i >= visibleCount) {
-						pane.hide();
+			let selectedIndex = 0;
+			let focus = "list";
+			let showFullTodoList = false;
+			function normalizeTaskText(taskText) {
+				return taskText.trim().replaceAll(/\s+/g, " ");
+			}
+			function getSelectedRuntimeTask() {
+				if (selectedIndex < 0) selectedIndex = 0;
+				if (selectedIndex >= runtime.length) selectedIndex = runtime.length - 1;
+				return runtime[selectedIndex];
+			}
+			function getFormattedLogLines(rt, options) {
+				const step = rt.aggregator.snapshot();
+				const blocks = [];
+				const reasoningWrapWidth = Math.max(1, options.widthHint);
+				const messageWrapWidth = Math.max(1, options.widthHint);
+				const toolById = new Map(step.toolActions.map((tool) => [tool.toolCallId, tool]));
+				function pushBlock(order, lines) {
+					if (lines.length === 0) return;
+					blocks.push({
+						order: order ?? Number.MAX_SAFE_INTEGER,
+						lines
+					});
+				}
+				for (let timelineIndex = 0; timelineIndex < step.timeline.length; timelineIndex++) {
+					const entry = step.timeline[timelineIndex];
+					if (entry.kind === "reasoning") {
+						const reasoningBlock = [];
+						const hasTrailingLineFeed = entry.text.endsWith("\n");
+						const rawReasoningLines = toDisplayLines(entry.text);
+						for (const rawLine of rawReasoningLines) wrapRawLineToWidth(rawLine, reasoningWrapWidth).forEach((chunk) => reasoningBlock.push(gray(chunk, options.style)));
+						if (!hasTrailingLineFeed) reasoningBlock.push("");
+						pushBlock(entry.order, reasoningBlock);
 						continue;
 					}
-					const rowIndex = Math.floor(i / gridCols);
-					const colIndex = i % gridCols;
-					const left = Math.floor(colIndex * columns / gridCols);
-					const right = Math.floor((colIndex + 1) * columns / gridCols);
-					const top = Math.floor(rowIndex * paneAreaHeight / gridRows);
-					const bottom = Math.floor((rowIndex + 1) * paneAreaHeight / gridRows);
-					pane.top = top;
-					pane.left = left;
-					pane.width = Math.max(1, right - left);
-					pane.height = Math.max(1, bottom - top);
-					pane.show();
+					if (entry.kind === "message") {
+						const messageBlock = [];
+						const rawMessageLines = toDisplayLines(entry.text);
+						for (const rawLine of rawMessageLines) wrapRawLineToWidth(rawLine, messageWrapWidth).forEach((chunk) => messageBlock.push(chunk));
+						pushBlock(entry.order, messageBlock);
+						continue;
+					}
+					if (entry.kind === "warning") {
+						pushBlock(entry.order, [kv("warning", yellow(entry.message, options.style), options.style)]);
+						continue;
+					}
+					const tool = toolById.get(entry.toolCallId);
+					if (!tool) continue;
+					const exploredSubLines = getExploredSubCommandLines(tool);
+					if (exploredSubLines != null) {
+						const groupedTools = [tool];
+						const groupedSubLines = [...exploredSubLines];
+						let lookahead = timelineIndex + 1;
+						while (lookahead < step.timeline.length) {
+							const next = step.timeline[lookahead];
+							if (next.kind !== "tool") break;
+							const nextTool = toolById.get(next.toolCallId);
+							if (!nextTool) break;
+							const nextSubLines = getExploredSubCommandLines(nextTool);
+							if (nextSubLines == null) break;
+							groupedTools.push(nextTool);
+							groupedSubLines.push(...nextSubLines);
+							lookahead += 1;
+						}
+						const groupedBlock = [`  ${[
+							formatToolStatusIcon(combineToolStatuses(groupedTools.map((groupedTool) => groupedTool.status)), options.style),
+							cyan("Explored", options.style),
+							groupedTools.length > 1 ? gray(`x${groupedTools.length}`, options.style) : void 0
+						].filter(Boolean).join(" ")}`];
+						groupedSubLines.forEach((subLine, subIndex) => groupedBlock.push(subIndex === 0 ? `      ${dimGray("└", options.style)} ${formatExploredSubCommandLine(subLine, options.style)}` : `        ${formatExploredSubCommandLine(subLine, options.style)}`));
+						pushBlock(entry.order, groupedBlock);
+						timelineIndex = lookahead - 1;
+						continue;
+					}
+					const toolBlock = [];
+					toDisplayLines(formatToolSummaryLine(tool, options.style)).forEach((line, index) => toolBlock.push(index === 0 ? `  ${line}` : `      ${line}`));
+					if (tool.toolName === "command_execution") formatToolResultPreviewLines(tool, {
+						maxLines: Number.MAX_SAFE_INTEGER,
+						widthHint: Math.max(20, options.widthHint - 10),
+						style: options.style
+					}).forEach((line, index) => toolBlock.push(index === 0 ? `      ${dimGray("└", options.style)} ${dimGray(line, options.style)}` : `        ${dimGray(line, options.style)}`));
+					pushBlock(entry.order, toolBlock);
 				}
-				return {
-					visibleCount,
-					hiddenCount: n - visibleCount
-				};
+				if (rt.lastError) pushBlock(void 0, [kv("error", red(rt.lastError, options.style), options.style)]);
+				blocks.sort((a, b) => a.order - b.order);
+				const lines = [];
+				for (const block of blocks) {
+					if (lines.length > 0 && lines[lines.length - 1] !== "") lines.push("");
+					lines.push(...block.lines);
+				}
+				if (lines.length === 0) lines.push(gray("(waiting for formatted stream output)", options.style));
+				return lines;
+			}
+			function moveTaskSelection(delta) {
+				if (runtime.length === 0) return;
+				selectedIndex = Math.max(0, Math.min(runtime.length - 1, selectedIndex + delta));
+			}
+			function scrollSelectedLog(delta) {
+				const selected = getSelectedRuntimeTask();
+				const viewport = getLogViewport(selected.target.task.id);
+				const bodyHeight = typeof rightBody.height === "number" ? rightBody.height : 0;
+				if (bodyHeight <= 0) return;
+				const bodyWidth = typeof rightBody.width === "number" ? rightBody.width : 80;
+				const lines = getFormattedLogLines(selected, {
+					style: useAnsiStyles(),
+					widthHint: Math.max(20, bodyWidth)
+				});
+				const maxOffset = Math.max(0, lines.length - bodyHeight);
+				viewport.autoFollow = false;
+				viewport.scrollOffset = Math.max(0, Math.min(maxOffset, viewport.scrollOffset + delta));
+			}
+			function scrollSelectedLogToTop() {
+				const viewport = getLogViewport(getSelectedRuntimeTask().target.task.id);
+				viewport.autoFollow = false;
+				viewport.scrollOffset = 0;
+			}
+			function scrollSelectedLogToBottom() {
+				const selected = getSelectedRuntimeTask();
+				const viewport = getLogViewport(selected.target.task.id);
+				const bodyHeight = typeof rightBody.height === "number" ? rightBody.height : 0;
+				if (bodyHeight <= 0) return;
+				const bodyWidth = typeof rightBody.width === "number" ? rightBody.width : 80;
+				const lines = getFormattedLogLines(selected, {
+					style: useAnsiStyles(),
+					widthHint: Math.max(20, bodyWidth)
+				});
+				const maxOffset = Math.max(0, lines.length - bodyHeight);
+				viewport.autoFollow = false;
+				viewport.scrollOffset = maxOffset;
+			}
+			function getHalfScreenScrollStep() {
+				const bodyHeight = typeof rightBody.height === "number" ? rightBody.height : 0;
+				return Math.max(1, Math.floor(bodyHeight / 2));
 			}
+			function resumeAutoFollowForSelectedLog() {
+				const viewport = getLogViewport(getSelectedRuntimeTask().target.task.id);
+				viewport.autoFollow = true;
+			}
+			screen.key(["left"], () => {
+				focus = "list";
+			});
+			screen.key(["right"], () => {
+				focus = "log";
+			});
+			screen.key(["up"], () => {
+				if (focus === "list") moveTaskSelection(-1);
+				else scrollSelectedLog(-getHalfScreenScrollStep());
+			});
+			screen.key(["down"], () => {
+				if (focus === "list") moveTaskSelection(1);
+				else scrollSelectedLog(getHalfScreenScrollStep());
+			});
+			screen.key(["g", "home"], () => {
+				if (focus !== "log") return;
+				scrollSelectedLogToTop();
+			});
+			screen.key([
+				"G",
+				"S-g",
+				"end"
+			], () => {
+				if (focus !== "log") return;
+				scrollSelectedLogToBottom();
+			});
+			screen.key(["f"], () => {
+				resumeAutoFollowForSelectedLog();
+			});
+			screen.key(["t"], () => {
+				showFullTodoList = !showFullTodoList;
+			});
 			const renderTimer = setInterval(() => {
 				const style = useAnsiStyles();
 				const columns = Math.max(40, screen.width ?? 120);
-				const layout = layoutPanes(columns, Math.max(8, screen.height ?? 24));
-				const nextFooterParts = ["Ctrl+C to exit", "q to quit"];
-				if (layout.hiddenCount > 0) nextFooterParts.push(`showing ${layout.visibleCount}/${runtime.length}`);
-				if (lastGlobalError) nextFooterParts.push(`error: ${lastGlobalError}`);
-				footer.setContent(nextFooterParts.join(" • "));
-				runtime.slice(0, layout.visibleCount).forEach((rt, idx) => {
-					const pane = panes[idx];
-					const paneWidth = typeof pane.width === "number" ? pane.width : Math.max(1, Math.floor(columns / Math.max(1, options.screen.cols)));
-					const paneInnerWidth = Math.max(0, paneWidth - 2);
-					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 = formatWrappedTextLines(step.leadingReasoning, {
-						maxLines: 6,
-						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 = [];
-					const followTools = step.toolActions.slice(-3);
-					for (const tool of followTools) {
-						toolLines.push(formatToolSummaryLine(tool, style));
-						if (tool.toolName !== "command_execution") continue;
-						formatToolResultPreviewLines(tool, {
-							maxLines: 2,
-							widthHint: Math.max(20, paneInnerWidth - 2),
-							style
-						}).forEach((line) => toolLines.push(` ${line}`));
-					}
-					const baseLines = [
-						...headerLines,
-						...reasoningLines,
-						...toolLines,
-						...messageLine ? [messageLine] : [],
-						...extraLines
-					];
-					pane.setLabel(title);
-					pane.setContent(baseLines.map((line) => clip(line, paneInnerWidth)).join("\n"));
+				const rows = Math.max(8, screen.height ?? 24);
+				const contentHeight = Math.max(1, rows - 1);
+				const minListWidth = 12;
+				const maxListWidth = Math.max(minListWidth, columns - 24);
+				const listWidth = Math.min(Math.max(minListWidth, options.listWidth), maxListWidth);
+				const rightPaneWidth = Math.max(1, columns - listWidth);
+				taskListPane.top = 0;
+				taskListPane.left = 0;
+				taskListPane.width = listWidth;
+				taskListPane.height = contentHeight;
+				taskListPane.setLabel(" Tasks ");
+				taskListPane.style.border = { fg: focus === "list" ? "cyan" : "gray" };
+				rightPane.top = 0;
+				rightPane.left = listWidth;
+				rightPane.width = rightPaneWidth;
+				rightPane.height = contentHeight;
+				rightPane.style.border = { fg: focus === "log" ? "cyan" : "gray" };
+				const selected = getSelectedRuntimeTask();
+				const selectedTaskId = selected.target.task.id;
+				const viewport = getLogViewport(selectedTaskId);
+				const snapshot = selected.aggregator.snapshot();
+				const paneInnerWidth = Math.max(1, rightPaneWidth - 2);
+				const paneInnerHeight = Math.max(1, contentHeight - 2);
+				const headerHeight = Math.min(2, paneInnerHeight);
+				const maxRightFooterHeight = Math.max(0, paneInnerHeight - headerHeight);
+				const visibleTodoPanelLines = trimLinesToHeight(formatTodoPanelLines({
+					todoItems: snapshot.todoItems,
+					fullView: showFullTodoList,
+					widthHint: paneInnerWidth,
+					style
+				}), maxRightFooterHeight, style);
+				const rightFooterHeight = visibleTodoPanelLines.length;
+				const bodyHeight = Math.max(0, paneInnerHeight - headerHeight - rightFooterHeight);
+				const listInnerWidth = Math.max(1, listWidth - 2);
+				const taskListItems = runtime.map((rt) => clip(`${rt.target.agent}: ${normalizeTaskText(rt.target.task.task)}`, listInnerWidth));
+				taskListPane.setItems(taskListItems);
+				taskListPane.select(selectedIndex);
+				rightPane.setLabel(` ${selected.target.agent} `);
+				rightHeader.top = 0;
+				rightHeader.left = 1;
+				rightHeader.width = paneInnerWidth;
+				rightHeader.height = headerHeight;
+				rightHeader.show();
+				const latestSnapId = selected.branch?.latest_snap_id ?? "(none)";
+				const streamId = selected.streamId ?? selected.branch?.latest_snap?.event_stream_id ?? "(none)";
+				const headerLines = [clip(`project id: ${selected.target.task.project_id} • task id: ${selected.target.task.id} • latest snap id: ${latestSnapId}`, paneInnerWidth), clip(`stream id: ${streamId}`, paneInnerWidth)];
+				rightHeader.setContent(headerLines.slice(0, headerHeight).join("\n"));
+				const formattedLogLines = getFormattedLogLines(selected, {
+					style,
+					widthHint: paneInnerWidth
 				});
+				const maxOffset = Math.max(0, formattedLogLines.length - bodyHeight);
+				if (viewport.autoFollow) viewport.scrollOffset = maxOffset;
+				else viewport.scrollOffset = Math.max(0, Math.min(maxOffset, viewport.scrollOffset));
+				rightBody.top = headerHeight + rightFooterHeight;
+				rightBody.left = 1;
+				rightBody.width = paneInnerWidth;
+				rightBody.height = bodyHeight;
+				if (bodyHeight <= 0) rightBody.hide();
+				else {
+					const visibleLines = formattedLogLines.slice(viewport.scrollOffset, viewport.scrollOffset + bodyHeight);
+					rightBody.setContent(visibleLines.map((line) => clip(line, paneInnerWidth)).join("\n"));
+					rightBody.show();
+				}
+				rightFooter.top = headerHeight;
+				rightFooter.left = 1;
+				rightFooter.width = paneInnerWidth;
+				rightFooter.height = rightFooterHeight;
+				if (rightFooterHeight <= 0) rightFooter.hide();
+				else {
+					rightFooter.setContent(visibleTodoPanelLines.map((line) => clip(line, paneInnerWidth)).join("\n"));
+					rightFooter.show();
+				}
+				const footerParts = [
+					"Ctrl+C to exit",
+					"q to quit",
+					"←/→ focus",
+					focus === "list" ? "↑/↓ select task" : "↑/↓ half-page",
+					"g/G top/bottom",
+					"f resume auto-scroll",
+					showFullTodoList ? "t todo preview" : "t todo full"
+				];
+				if (!viewport.autoFollow) footerParts.push("auto-scroll paused");
+				if (lastGlobalError) footerParts.push(`error: ${clip(lastGlobalError, 40)}`);
+				globalFooter.setContent(footerParts.join(" • "));
 				screen.render();
 			}, 300);
 			let pollTimer;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pantheon.ai/agents",
   "type": "module",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "bin": {
     "pantheon-agents": "dist/index.js"
   },
@@ -21,6 +21,7 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@openrouter/ai-sdk-provider": "^2.2.3",
     "@types/express": "^5.0.6",
+    "@types/shell-quote": "^1.7.5",
     "commander": "^14.0.3",
     "dotenv": "^17.2.4",
     "expand-tilde": "^2.0.2",
@@ -31,6 +32,7 @@
     "pino-pretty": "^13.1.3",
     "pino-roll": "^4.0.0",
     "reblessed": "^0.2.1",
+    "shell-quote": "^1.8.3",
     "smol-toml": "^1.6.0",
     "zod": "^4.3.6"
   },