@oh-my-pi/pi-coding-agent 3.15.1 → 3.20.0

package/src/core/tools/task/discovery.ts

@@ -154,7 +154,7 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentDefinition[]
  *
  * @param cwd - Current working directory for project agent discovery
  */
-export function discoverAgents(cwd: string): DiscoveryResult {
+export async function discoverAgents(cwd: string): Promise<DiscoveryResult> {
 	const resolvedCwd = path.resolve(cwd);
 	const agentSources = Array.from(new Set(getConfigDirs("", { project: false }).map((entry) => entry.source)));
 
@@ -167,7 +167,7 @@ export function discoverAgents(cwd: string): DiscoveryResult {
 		}));
 
 	// Get project directories by walking up from cwd (priority order)
-	const projectDirs = findAllNearestProjectConfigDirs("agents", resolvedCwd)
+	const projectDirs = (await findAllNearestProjectConfigDirs("agents", resolvedCwd))
 		.filter((entry) => agentSources.includes(entry.source))
 		.map((entry) => ({
 			...entry,

package/src/core/tools/task/executor.ts

@@ -5,13 +5,12 @@
  * Parses JSON events for progress tracking.
  */
 
-import { spawn } from "node:child_process";
-import * as fs from "node:fs";
-import * as os from "node:os";
+import { existsSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import * as path from "node:path";
-import * as readline from "node:readline";
 import { ensureArtifactsDir, getArtifactPaths } from "./artifacts";
 import { resolveModelPattern } from "./model-resolver";
+import { resolveOmpCommand } from "./omp-command";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import {
 	type AgentDefinition,
@@ -23,17 +22,12 @@ import {
 	type SingleResult,
 } from "./types";
 
-/** omp command: 'omp.cmd' on Windows, 'omp' elsewhere */
-const OMP_CMD = process.platform === "win32" ? "omp.cmd" : "omp";
-
-/** Windows shell option for spawn */
-const OMP_SHELL_OPT = process.platform === "win32";
-
 /** Options for subprocess execution */
 export interface ExecutorOptions {
 	cwd: string;
 	agent: AgentDefinition;
 	task: string;
+	description?: string;
 	index: number;
 	context?: string;
 	modelOverride?: string;
@@ -146,6 +140,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		agentSource: agent.source,
 		status: "running",
 		task,
+		description: options.description,
 		recentTools: [],
 		recentOutput: [],
 		toolCount: 0,
@@ -161,6 +156,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			agent: agent.name,
 			agentSource: agent.source,
 			task,
+			description: options.description,
 			exitCode: 1,
 			output: "",
 			stderr: "Aborted before start",
@@ -173,20 +169,21 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	// Write system prompt to temp file
-	const tempDir = os.tmpdir();
+	const tempDir = tmpdir();
 	const promptFile = path.join(
 		tempDir,
 		`omp-agent-${agent.name}-${Date.now()}-${Math.random().toString(36).slice(2)}.md`,
 	);
 
 	try {
-		fs.writeFileSync(promptFile, agent.systemPrompt, "utf-8");
+		writeFileSync(promptFile, agent.systemPrompt, "utf-8");
 	} catch (err) {
 		return {
 			index,
 			agent: agent.name,
 			agentSource: agent.source,
 			task,
+			description: options.description,
 			exitCode: 1,
 			output: "",
 			stderr: `Failed to write prompt file: ${err}`,
@@ -212,7 +209,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 		// Write input file immediately (real-time visibility)
 		try {
-			fs.writeFileSync(artifactPaths.inputPath, fullTask, "utf-8");
+			writeFileSync(artifactPaths.inputPath, fullTask, "utf-8");
 		} catch {
 			// Non-fatal, continue without input artifact
 		}
@@ -268,10 +265,12 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	// Spawn subprocess
-	const proc = spawn(OMP_CMD, args, {
+	const ompCommand = resolveOmpCommand();
+	const proc = Bun.spawn([ompCommand.cmd, ...ompCommand.args, ...args], {
 		cwd,
-		stdio: ["ignore", "pipe", "pipe"],
-		shell: OMP_SHELL_OPT,
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
 		env,
 	});
 
@@ -285,7 +284,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	// Handle abort signal
 	const onAbort = () => {
 		if (!resolved) {
-			proc.kill("SIGTERM");
+			proc.kill(15); // SIGTERM
 		}
 	};
 	if (signal) {
@@ -293,9 +292,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	// Parse JSON events from stdout
-	const rl = readline.createInterface({ input: proc.stdout! });
+	const reader = proc.stdout.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
 
-	rl.on("line", (line) => {
+	const processLine = (line: string) => {
 		if (resolved) return;
 
 		try {
@@ -362,7 +363,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 							setTimeout(() => {
 								if (!resolved) {
 									resolved = true;
-									proc.kill("SIGTERM");
+									proc.kill(15); // SIGTERM
 								}
 							}, 2000);
 						}
@@ -406,7 +407,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					// If pending termination, now we have tokens - terminate
 					if (pendingTermination && !resolved) {
 						resolved = true;
-						proc.kill("SIGTERM");
+						proc.kill(15); // SIGTERM
 					}
 					break;
 				}
@@ -433,45 +434,49 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		} catch {
 			// Ignore non-JSON lines
 		}
-	});
-
-	// Capture stderr
-	const stderrDecoder = new TextDecoder();
-	proc.stderr?.on("data", (chunk: Buffer) => {
-		stderr += stderrDecoder.decode(chunk, { stream: true });
-	});
+	};
 
-	// Wait for readline to finish BEFORE resolving
-	const exitCode = await new Promise<number>((resolve) => {
-		let code: number | null = null;
-		let rlClosed = false;
-		let procClosed = false;
+	// Read stdout asynchronously
+	const stdoutDone = (async () => {
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() || "";
+				for (const line of lines) {
+					processLine(line);
+				}
+			}
+			// Process remaining buffer
+			if (buffer.trim()) {
+				processLine(buffer);
+			}
+		} catch {
+			// Ignore read errors
+		}
+	})();
 
-		const maybeResolve = () => {
-			if (rlClosed && procClosed) {
-				resolved = true;
-				resolve(code ?? 1);
+	// Capture stderr - Bun.spawn returns ReadableStream, convert to text
+	const stderrDone = (async () => {
+		try {
+			const stderrReader = proc.stderr.getReader();
+			const stderrDecoder = new TextDecoder();
+			while (true) {
+				const { done, value } = await stderrReader.read();
+				if (done) break;
+				stderr += stderrDecoder.decode(value, { stream: true });
 			}
-		};
+		} catch {
+			// Ignore stderr read errors
+		}
+	})();
 
-		rl.on("close", () => {
-			rlClosed = true;
-			maybeResolve();
-		});
-
-		proc.on("close", (c) => {
-			code = c;
-			procClosed = true;
-			maybeResolve();
-		});
-
-		proc.on("error", (err) => {
-			stderr += `\nProcess error: ${err.message}`;
-			code = 1;
-			procClosed = true;
-			maybeResolve();
-		});
-	});
+	// Wait for process and stream readers to finish
+	const exitCode = await proc.exited;
+	await Promise.all([stdoutDone, stderrDone]);
+	resolved = true;
 
 	// Cleanup
 	if (signal) {
@@ -479,7 +484,9 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	try {
-		fs.unlinkSync(promptFile);
+		if (existsSync(promptFile)) {
+			unlinkSync(promptFile);
+		}
 	} catch {
 		// Ignore cleanup errors
 	}
@@ -493,7 +500,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	let outputMeta: { lineCount: number; charCount: number } | undefined;
 	if (artifactPaths) {
 		try {
-			fs.writeFileSync(artifactPaths.outputPath, rawOutput, "utf-8");
+			writeFileSync(artifactPaths.outputPath, rawOutput, "utf-8");
 			outputMeta = {
 				lineCount: rawOutput.split("\n").length,
 				charCount: rawOutput.length,
@@ -514,6 +521,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		agent: agent.name,
 		agentSource: agent.source,
 		task,
+		description: options.description,
 		exitCode,
 		output: truncatedOutput,
 		stderr,

package/src/core/tools/task/index.ts

@@ -16,11 +16,12 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import type { Theme } from "../../../modes/interactive/theme/theme";
+import { formatDuration } from "../render-utils";
 import { cleanupTempDir, createTempArtifactsDir, getArtifactsDir } from "./artifacts";
 import { discoverAgents, getAgent } from "./discovery";
 import { runSubprocess } from "./executor";
 import { mapWithConcurrencyLimit } from "./parallel";
-import { formatDuration, renderCall, renderResult } from "./render";
+import { renderCall, renderResult } from "./render";
 import {
 	type AgentProgress,
 	MAX_AGENTS_IN_DESCRIPTION,
@@ -137,8 +138,8 @@ export { taskSchema } from "./types";
 /**
  * Build dynamic tool description listing available agents.
  */
-function buildDescription(cwd: string): string {
-	const { agents } = discoverAgents(cwd);
+async function buildDescription(cwd: string): Promise<string> {
+	const { agents } = await discoverAgents(cwd);
 
 	const lines: string[] = [];
 
@@ -194,7 +195,7 @@ function buildDescription(cwd: string): string {
 	lines.push("");
 	lines.push("Parameters:");
 	lines.push(
-		`- tasks: Array of {agent, task, model?} - tasks to run in parallel (max ${MAX_PARALLEL_TASKS}, ${MAX_CONCURRENCY} concurrent)`,
+		`- tasks: Array of {agent, task, description?, model?} - tasks to run in parallel (max ${MAX_PARALLEL_TASKS}, ${MAX_CONCURRENCY} concurrent)`,
 	);
 	lines.push(
 		'  - model: (optional) Override the agent\'s default model with fuzzy matching (e.g., "sonnet", "codex", "5.2"). Supports comma-separated fallbacks: "gpt, opus" tries gpt first, then opus. Use "default" for omp\'s default model',
@@ -257,11 +258,11 @@ function buildDescription(cwd: string): string {
 /**
  * Create the task tool configured for a specific working directory.
  */
-export function createTaskTool(
+export async function createTaskTool(
 	cwd: string,
 	sessionContext?: SessionContext,
 	options?: TaskToolOptions,
-): AgentTool<typeof taskSchema, TaskToolDetails, Theme> {
+): Promise<AgentTool<typeof taskSchema, TaskToolDetails, Theme>> {
 	const hasOutputTool = options?.availableTools?.has("output") ?? false;
 	// Check if subagents are completely inhibited (legacy recursion prevention)
 	if (process.env[OMP_NO_SUBAGENTS_ENV]) {
@@ -287,13 +288,13 @@ export function createTaskTool(
 	return {
 		name: "task",
 		label: "Task",
-		description: buildDescription(cwd),
+		description: await buildDescription(cwd),
 		parameters: taskSchema,
 		renderCall,
 		renderResult,
 		execute: async (_toolCallId, params, signal, onUpdate) => {
 			const startTime = Date.now();
-			const { agents, projectAgentsDir } = discoverAgents(cwd);
+			const { agents, projectAgentsDir } = await discoverAgents(cwd);
 			const context = params.context;
 
 			// Handle empty or missing tasks
@@ -435,6 +436,7 @@ export function createTaskTool(
 						tokens: 0,
 						durationMs: 0,
 						modelOverride: tasks[i].model,
+						description: tasks[i].description,
 					});
 				}
 				emitProgress();
@@ -444,6 +446,7 @@ export function createTaskTool(
 					agent: t.agent,
 					task: context ? `${context}\n\n${t.task}` : t.task,
 					model: t.model,
+					description: t.description,
 				}));
 
 				// Execute in parallel with concurrency limit
@@ -453,6 +456,7 @@ export function createTaskTool(
 						cwd,
 						agent,
 						task: task.task,
+						description: task.description,
 						index,
 						context: undefined, // Already prepended above
 						modelOverride: task.model,
@@ -544,5 +548,20 @@ export function createTaskTool(
 	};
 }
 
-// Default task tool using process.cwd()
-export const taskTool = createTaskTool(process.cwd());
+// Default task tool using process.cwd() - returns a placeholder sync tool
+// Real implementations should use createTaskTool() which properly initializes the tool
+export const taskTool: AgentTool<typeof taskSchema, TaskToolDetails, Theme> = {
+	name: "task",
+	label: "Task",
+	description:
+		"Launch a new agent to handle complex, multi-step tasks autonomously. (Agent discovery pending - use createTaskTool for full functionality)",
+	parameters: taskSchema,
+	execute: async () => ({
+		content: [{ type: "text", text: "Task tool not properly initialized. Use createTaskTool(cwd) instead." }],
+		details: {
+			projectAgentsDir: null,
+			results: [],
+			totalDurationMs: 0,
+		},
+	}),
+};

package/src/core/tools/task/model-resolver.ts

@@ -11,15 +11,9 @@
  *   - "omp/slow" → configured slow model from settings
  */
 
-import { spawnSync } from "node:child_process";
 import { type Settings, settingsCapability } from "../../../capability/settings";
 import { loadSync } from "../../../discovery";
-
-/** omp command: 'omp.cmd' on Windows, 'omp' elsewhere */
-const OMP_CMD = process.platform === "win32" ? "omp.cmd" : "omp";
-
-/** Windows shell option for spawn/spawnSync */
-const OMP_SHELL_OPT = process.platform === "win32";
+import { resolveOmpCommand } from "./omp-command";
 
 /** Cache for available models (provider/modelId format) */
 let cachedModels: string[] | null = null;
@@ -41,20 +35,21 @@ export function getAvailableModels(): string[] {
 	}
 
 	try {
-		const result = spawnSync(OMP_CMD, ["--list-models"], {
-			encoding: "utf-8",
-			timeout: 5000,
-			shell: OMP_SHELL_OPT,
+		const ompCommand = resolveOmpCommand();
+		const result = Bun.spawnSync([ompCommand.cmd, ...ompCommand.args, "--list-models"], {
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe",
 		});
 
-		if (result.status !== 0 || !result.stdout) {
+		if (result.exitCode !== 0 || !result.stdout) {
 			cachedModels = [];
 			cacheExpiry = now + CACHE_TTL_MS;
 			return cachedModels;
 		}
 
 		// Parse output: skip header line, extract provider/model
-		const lines = result.stdout.trim().split("\n");
+		const lines = result.stdout.toString().trim().split("\n");
 		cachedModels = lines
 			.slice(1) // Skip header
 			.map((line) => {

package/src/core/tools/task/omp-command.ts

@@ -0,0 +1,24 @@
+import process from "node:process";
+
+interface OmpCommand {
+	cmd: string;
+	args: string[];
+	shell: boolean;
+}
+
+const DEFAULT_CMD = process.platform === "win32" ? "omp.cmd" : "omp";
+const DEFAULT_SHELL = process.platform === "win32";
+
+export function resolveOmpCommand(): OmpCommand {
+	const envCmd = process.env.OMP_SUBPROCESS_CMD;
+	if (envCmd?.trim()) {
+		return { cmd: envCmd, args: [], shell: DEFAULT_SHELL };
+	}
+
+	const entry = process.argv[1];
+	if (entry && (entry.endsWith(".ts") || entry.endsWith(".js"))) {
+		return { cmd: process.execPath, args: [entry], shell: false };
+	}
+
+	return { cmd: DEFAULT_CMD, args: [], shell: DEFAULT_SHELL };
+}

package/src/core/tools/task/render.ts

@@ -10,6 +10,14 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Container, Text } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../../../modes/interactive/theme/theme";
 import type { RenderResultOptions } from "../../custom-tools/types";
+import {
+	formatBadge,
+	formatDuration,
+	formatMoreItems,
+	formatTokens,
+	getStyledStatusIcon,
+	truncate,
+} from "../render-utils";
 import type { ReportFindingDetails, SubmitReviewDetails } from "../review";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import type { AgentProgress, SingleResult, TaskParams, TaskToolDetails } from "./types";
@@ -22,63 +30,26 @@ const PRIORITY_LABELS: Record<number, string> = {
 	3: "P3",
 };
 
-/**
- * Format token count for display (e.g., 1.5k, 25k).
- */
-function formatTokens(tokens: number): string {
-	if (tokens >= 1000) {
-		return `${(tokens / 1000).toFixed(1)}k`;
-	}
-	return String(tokens);
-}
-
-/**
- * Format duration for display.
- */
-export function formatDuration(ms: number): string {
-	if (ms < 1000) return `${ms}ms`;
-	if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-	return `${(ms / 60000).toFixed(1)}m`;
-}
-
-/**
- * Truncate text to max length with ellipsis.
- */
-function truncate(text: string, maxLen: number, ellipsis: string): string {
-	if (text.length <= maxLen) return text;
-	const sliceLen = Math.max(0, maxLen - ellipsis.length);
-	return `${text.slice(0, sliceLen)}${ellipsis}`;
-}
-
 /**
  * Get status icon for agent state.
  * For running status, uses animated spinner if spinnerFrame is provided.
+ * Maps AgentProgress status to styled icon format.
  */
 function getStatusIcon(status: AgentProgress["status"], theme: Theme, spinnerFrame?: number): string {
 	switch (status) {
 		case "pending":
-			return theme.status.pending;
-		case "running": {
-			// Use animated spinner if frame is provided, otherwise static icon
-			if (spinnerFrame === undefined) return theme.status.running;
-			const frames = theme.spinnerFrames;
-			return frames[spinnerFrame % frames.length];
-		}
+			return getStyledStatusIcon("pending", theme);
+		case "running":
+			return getStyledStatusIcon("running", theme, spinnerFrame);
 		case "completed":
-			return theme.status.success;
+			return getStyledStatusIcon("success", theme);
 		case "failed":
-			return theme.status.error;
+			return getStyledStatusIcon("error", theme);
 		case "aborted":
-			return theme.status.aborted;
+			return getStyledStatusIcon("aborted", theme);
 	}
 }
 
-function formatBadge(label: string, color: "success" | "error" | "warning" | "accent" | "muted", theme: Theme): string {
-	const left = theme.format.bracketLeft;
-	const right = theme.format.bracketRight;
-	return theme.fg(color, `${left}${label}${right}`);
-}
-
 function formatFindingSummary(findings: ReportFindingDetails[], theme: Theme): string {
 	if (findings.length === 0) return theme.fg("dim", "Findings: none");
 
@@ -119,10 +90,7 @@ function renderOutputSection(
 
 	if (outputLines.length > previewCount) {
 		lines.push(
-			`${continuePrefix}  ${theme.fg(
-				"dim",
-				`${theme.format.ellipsis} ${outputLines.length - previewCount} more lines`,
-			)}`,
+			`${continuePrefix}  ${theme.fg("dim", formatMoreItems(outputLines.length - previewCount, "line", theme))}`,
 		);
 	}
 
@@ -133,12 +101,13 @@ function renderOutputSection(
  * Render the tool call arguments.
  */
 export function renderCall(args: TaskParams, theme: Theme): Component {
-	const label = theme.fg("toolTitle", theme.bold("task"));
+	const label = theme.fg("toolTitle", theme.bold("Task"));
 
 	if (args.tasks.length === 1) {
 		// Single task - show agent and task preview
 		const task = args.tasks[0];
-		const taskPreview = truncate(task.task, 60, theme.format.ellipsis);
+		const summary = task.description?.trim() || task.task;
+		const taskPreview = truncate(summary, 60, theme.format.ellipsis);
 		return new Text(`${label} ${theme.fg("accent", task.agent)}: ${theme.fg("muted", taskPreview)}`, 0, 0);
 	}
 
@@ -178,6 +147,10 @@ function renderAgentProgress(
 	// Main status line - include index for Output tool ID derivation
 	const agentId = `${progress.agent}(${progress.index})`;
 	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", agentId)}`;
+	const description = progress.description?.trim();
+	if (description) {
+		statusLine += ` ${theme.fg("muted", truncate(description, 40, theme.format.ellipsis))}`;
+	}
 
 	// Only show badge for non-running states (spinner already indicates running)
 	if (progress.status !== "running") {
@@ -193,8 +166,10 @@ function renderAgentProgress(
 	}
 
 	if (progress.status === "running") {
-		const taskPreview = truncate(progress.task, 40, theme.format.ellipsis);
-		statusLine += ` ${theme.fg("muted", taskPreview)}`;
+		if (!description) {
+			const taskPreview = truncate(progress.task, 40, theme.format.ellipsis);
+			statusLine += ` ${theme.fg("muted", taskPreview)}`;
+		}
 		statusLine += `${theme.sep.dot}${theme.fg("dim", `${progress.toolCount} tools`)}`;
 		if (progress.tokens > 0) {
 			statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatTokens(progress.tokens)} tokens`)}`;
@@ -235,9 +210,7 @@ function renderAgentProgress(
 					}
 				}
 				if (dataArray.length > 3) {
-					lines.push(
-						`${continuePrefix}${theme.fg("dim", `${theme.format.ellipsis} ${dataArray.length - 3} more`)}`,
-					);
+					lines.push(`${continuePrefix}${theme.fg("dim", formatMoreItems(dataArray.length - 3, "item", theme))}`);
 				}
 			}
 		}
@@ -337,9 +310,7 @@ function renderFindings(
 	}
 
 	if (!expanded && findings.length > 3) {
-		lines.push(
-			`${continuePrefix}${theme.fg("dim", `${theme.format.ellipsis} ${findings.length - 3} more findings`)}`,
-		);
+		lines.push(`${continuePrefix}${theme.fg("dim", formatMoreItems(findings.length - 3, "finding", theme))}`);
 	}
 
 	return lines;
@@ -364,6 +335,10 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	// Main status line - include index for Output tool ID derivation
 	const agentId = `${result.agent}(${result.index})`;
 	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", agentId)} ${formatBadge(statusText, iconColor, theme)}`;
+	const description = result.description?.trim();
+	if (description) {
+		statusLine += ` ${theme.fg("muted", truncate(description, 40, theme.format.ellipsis))}`;
+	}
 	if (result.tokens > 0) {
 		statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatTokens(result.tokens)} tokens`)}`;
 	}
@@ -479,11 +454,11 @@ export function renderResult(
 		let summary = `\n${theme.fg("dim", "Total:")} `;
 		if (abortedCount > 0) {
 			summary += theme.fg("error", `${abortedCount} aborted`);
-			if (successCount > 0 || failCount > 0) summary += ", ";
+			if (successCount > 0 || failCount > 0) summary += theme.sep.dot;
 		}
 		if (successCount > 0) {
 			summary += theme.fg("success", `${successCount} succeeded`);
-			if (failCount > 0) summary += ", ";
+			if (failCount > 0) summary += theme.sep.dot;
 		}
 		if (failCount > 0) {
 			summary += theme.fg("error", `${failCount} failed`);

package/src/core/tools/task/types.ts

@@ -32,6 +32,7 @@ export const OMP_SPAWNS_ENV = "OMP_SPAWNS";
 export const taskItemSchema = Type.Object({
 	agent: Type.String({ description: "Agent name" }),
 	task: Type.String({ description: "Task description for the agent" }),
+	description: Type.Optional(Type.String({ description: "Short description for UI display" })),
 	model: Type.Optional(Type.String({ description: "Model override for this task" })),
 });
 
@@ -92,6 +93,7 @@ export interface AgentProgress {
 	agentSource: AgentSource;
 	status: "pending" | "running" | "completed" | "failed" | "aborted";
 	task: string;
+	description?: string;
 	currentTool?: string;
 	currentToolArgs?: string;
 	currentToolStartMs?: number;
@@ -111,6 +113,7 @@ export interface SingleResult {
 	agent: string;
 	agentSource: AgentSource;
 	task: string;
+	description?: string;
 	exitCode: number;
 	output: string;
 	stderr: string;