@oh-my-pi/pi-coding-agent 6.9.0 → 6.9.69

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

@@ -28,12 +28,14 @@ import { discoverAgents, getAgent } from "./discovery";
 import { runSubprocess } from "./executor";
 import { mapWithConcurrencyLimit } from "./parallel";
 import { renderCall, renderResult } from "./render";
+import { renderTemplate, validateTaskTemplate } from "./template";
 import {
 	type AgentProgress,
 	MAX_AGENTS_IN_DESCRIPTION,
 	MAX_CONCURRENCY,
 	MAX_PARALLEL_TASKS,
 	type SingleResult,
+	type TaskParams,
 	type TaskToolDetails,
 	taskSchema,
 } from "./types";
@@ -112,14 +114,6 @@ async function buildDescription(cwd: string): Promise<string> {
 // Tool Class
 // ═══════════════════════════════════════════════════════════════════════════
 
-type TaskParams = {
-	agent: string;
-	context?: string;
-	model?: string;
-	output?: unknown;
-	tasks: Array<{ id: string; task: string; description: string }>;
-};
-
 /**
  * Task tool - Delegate tasks to specialized agents.
  *
@@ -201,7 +195,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				content: [
 					{
 						type: "text",
-						text: `No tasks provided. Use: { agent, context, tasks: [{id, task, description}, ...] }`,
+						text: `No tasks provided. Use: { agent, context, tasks: [{id, description, vars}, ...] }`,
 					},
 				],
 				details: {
@@ -277,6 +271,18 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			};
 		}
 
+		const templateError = validateTaskTemplate(context, tasks);
+		if (templateError) {
+			return {
+				content: [{ type: "text", text: templateError }],
+				details: {
+					projectAgentsDir,
+					results: [],
+					totalDurationMs: 0,
+				},
+			};
+		}
+
 		// Derive artifacts directory
 		const sessionFile = this.session.getSessionFile();
 		const artifactsDir = sessionFile ? sessionFile.slice(0, -6) : null;
@@ -341,10 +347,12 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			}
 
 			// Build full prompts with context prepended
+			const contextTemplate = context ?? "";
 			const tasksWithContext = tasks.map((t) => ({
-				task: context ? `${context}\n\n${t.task}` : t.task,
+				task: renderTemplate(contextTemplate, t.vars),
 				description: t.description,
 				taskId: t.id,
+				vars: t.vars,
 			}));
 
 			// Initialize progress for all tasks
@@ -357,6 +365,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 					agentSource: agent.source,
 					status: "pending",
 					task: t.task,
+					vars: t.vars,
 					recentTools: [],
 					recentOutput: [],
 					toolCount: 0,
@@ -391,7 +400,10 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						signal,
 						eventBus: undefined,
 						onProgress: (progress) => {
-							progressMap.set(index, structuredClone(progress));
+							progressMap.set(index, {
+								...structuredClone(progress),
+								vars: tasksWithContext[index]?.vars,
+							});
 							emitProgress();
 						},
 						authStorage: this.session.authStorage,
@@ -405,7 +417,12 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 
 			// Fill in skipped tasks (undefined entries from abort) with placeholder results
 			const results: SingleResult[] = partialResults.map((result, index) => {
-				if (result !== undefined) return result;
+				if (result !== undefined) {
+					return {
+						...result,
+						vars: tasksWithContext[index]?.vars,
+					};
+				}
 				const task = tasksWithContext[index];
 				return {
 					index,
@@ -413,6 +430,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 					agent: agentName,
 					agentSource: agent.source,
 					task: task.task,
+					vars: task.vars,
 					description: task.description,
 					exitCode: 1,
 					output: "",

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

@@ -67,9 +67,12 @@ function formatFindingSummary(findings: ReportFindingDetails[], theme: Theme): s
 	return `${theme.fg("dim", "Findings:")} ${parts.join(theme.sep.dot)}`;
 }
 
-function formatJsonScalar(value: unknown): string {
+function formatJsonScalar(value: unknown, theme: Theme): string {
 	if (value === null) return "null";
-	if (typeof value === "string") return `"${value}"`;
+	if (typeof value === "string") {
+		const trimmed = truncate(value, 70, theme.format.ellipsis);
+		return `"${trimmed}"`;
+	}
 	if (typeof value === "number" || typeof value === "boolean") return String(value);
 	return "";
 }
@@ -108,7 +111,7 @@ function renderJsonTreeLines(
 
 		const connector = isLast ? theme.tree.last : theme.tree.branch;
 		const prefix = `${buildTreePrefix(ancestors, theme)}${theme.fg("dim", connector)} `;
-		const scalar = formatJsonScalar(val);
+		const scalar = formatJsonScalar(val, theme);
 
 		if (scalar) {
 			const label = key ? theme.fg("muted", key) : theme.fg("muted", "value");
@@ -186,7 +189,33 @@ function renderJsonTreeLines(
 		pushLine(`${prefix}${iconScalar} ${label}: ${theme.fg("dim", String(val))}`);
 	};
 
-	renderNode(value, undefined, [], true, 0);
+	const renderRoot = (val: unknown) => {
+		if (Array.isArray(val)) {
+			for (let i = 0; i < val.length; i++) {
+				renderNode(val[i], `[${i}]`, [], i === val.length - 1, 1);
+				if (lines.length >= maxLines) {
+					truncated = true;
+					return;
+				}
+			}
+			return;
+		}
+		if (val && typeof val === "object") {
+			const entries = Object.entries(val as Record<string, unknown>);
+			for (let i = 0; i < entries.length; i++) {
+				const [childKey, child] = entries[i];
+				renderNode(child, childKey, [], i === entries.length - 1, 1);
+				if (lines.length >= maxLines) {
+					truncated = true;
+					return;
+				}
+			}
+			return;
+		}
+		renderNode(val, undefined, [], true, 0);
+	};
+
+	renderRoot(value);
 
 	return { lines, truncated };
 }
@@ -203,11 +232,18 @@ function renderOutputSection(
 	const trimmedOutput = output.trim();
 	if (!trimmedOutput) return lines;
 
-	lines.push(`${continuePrefix}${theme.fg("dim", "Output")}`);
-
 	if (trimmedOutput.startsWith("{") || trimmedOutput.startsWith("[")) {
 		try {
 			const parsed = JSON.parse(trimmedOutput);
+
+			// Collapsed: inline format like Vars
+			if (!expanded) {
+				lines.push(`${continuePrefix}${theme.fg("dim", formatOutputInline(parsed, theme))}`);
+				return lines;
+			}
+
+			// Expanded: tree format
+			lines.push(`${continuePrefix}${theme.fg("dim", "Output")}`);
 			const tree = renderJsonTreeLines(parsed, theme, expanded ? 6 : 2, expanded ? 24 : 6);
 			if (tree.lines.length > 0) {
 				for (const line of tree.lines) {
@@ -223,6 +259,8 @@ function renderOutputSection(
 		}
 	}
 
+	lines.push(`${continuePrefix}${theme.fg("dim", "Output")}`);
+
 	const outputLines = output.split("\n").filter((line) => line.trim());
 	const previewCount = expanded ? maxExpanded : maxCollapsed;
 	for (const line of outputLines.slice(0, previewCount)) {
@@ -238,6 +276,92 @@ function renderOutputSection(
 	return lines;
 }
 
+function formatVarsInline(vars: Record<string, string>, theme: Theme): string {
+	const entries = Object.entries(vars);
+	if (entries.length === 0) return "Vars: none";
+	const pairs = entries.map(([key, value]) => `${key}=${truncate(value, 24, theme.format.ellipsis)}`);
+	return `Vars: ${pairs.join(", ")}`;
+}
+
+function formatScalarInline(value: unknown, maxLen: number, theme: Theme): string {
+	if (value === null) return "null";
+	if (value === undefined) return "undefined";
+	if (typeof value === "boolean") return String(value);
+	if (typeof value === "number") return String(value);
+	if (typeof value === "string") return `"${truncate(value, maxLen, theme.format.ellipsis)}"`;
+	if (Array.isArray(value)) return `[${value.length} items]`;
+	if (typeof value === "object") {
+		const keys = Object.keys(value);
+		return `{${keys.length} keys}`;
+	}
+	return String(value);
+}
+
+function formatOutputInline(data: unknown, theme: Theme, maxWidth = 80): string {
+	if (data === null || data === undefined) return "Output: none";
+
+	// For scalars, show directly
+	if (typeof data !== "object") {
+		return `Output: ${formatScalarInline(data, 60, theme)}`;
+	}
+
+	// For arrays, show count and first element preview
+	if (Array.isArray(data)) {
+		if (data.length === 0) return "Output: []";
+		const preview = formatScalarInline(data[0], 40, theme);
+		return `Output: [${data.length} items] ${preview}${data.length > 1 ? theme.format.ellipsis : ""}`;
+	}
+
+	// For objects, show key=value pairs inline
+	const entries = Object.entries(data as Record<string, unknown>);
+	if (entries.length === 0) return "Output: {}";
+
+	const pairs: string[] = [];
+	let totalLen = "Output: ".length;
+
+	for (const [key, value] of entries) {
+		const valueStr = formatScalarInline(value, 24, theme);
+		const pairStr = `${key}=${valueStr}`;
+		const addLen = pairs.length > 0 ? pairStr.length + 2 : pairStr.length; // +2 for ", "
+
+		if (totalLen + addLen > maxWidth && pairs.length > 0) {
+			pairs.push(theme.format.ellipsis);
+			break;
+		}
+
+		pairs.push(pairStr);
+		totalLen += addLen;
+	}
+
+	return `Output: ${pairs.join(", ")}`;
+}
+
+function renderVarsSection(
+	vars: Record<string, string> | undefined,
+	continuePrefix: string,
+	expanded: boolean,
+	theme: Theme,
+): string[] {
+	if (!vars || Object.keys(vars).length === 0) return [];
+	const lines: string[] = [];
+
+	if (!expanded) {
+		lines.push(`${continuePrefix}${theme.fg("dim", formatVarsInline(vars, theme))}`);
+		return lines;
+	}
+
+	lines.push(`${continuePrefix}${theme.fg("dim", "Vars")}`);
+	const tree = renderJsonTreeLines(vars, theme, 4, 16);
+	for (const line of tree.lines) {
+		lines.push(`${continuePrefix}  ${line}`);
+	}
+	if (tree.truncated) {
+		lines.push(`${continuePrefix}  ${theme.fg("dim", theme.format.ellipsis)}`);
+	}
+
+	return lines;
+}
+
 /**
  * Render the tool call arguments.
  */
@@ -247,24 +371,29 @@ export function renderCall(args: TaskParams, theme: Theme): Component {
 		theme.fg("dim", `${theme.format.bracketLeft}${args.agent}${theme.format.bracketRight}`),
 	);
 
-	if (args.tasks.length === 1) {
-		// Single task - show description preview
-		const task = args.tasks[0];
-		const summary = task.description.trim() || task.task;
-		const taskPreview = truncate(summary, 50, theme.format.ellipsis);
-		return new Text(`${label} ${agentTag} ${theme.fg("muted", taskPreview)}`, 0, 0);
-	}
-
-	// Multiple tasks - show count and descriptions
-	const descriptions = args.tasks.map((t) => t.description.trim()).join(", ");
-	return new Text(
-		`${label} ${agentTag} ${args.tasks.length} agents: ${theme.fg(
-			"muted",
-			truncate(descriptions, 50, theme.format.ellipsis),
-		)}`,
-		0,
-		0,
-	);
+	const lines: string[] = [];
+	lines.push(`${label} ${agentTag}`);
+
+	const contextTemplate = args.context ?? "";
+	const context = contextTemplate.trim();
+	const hasContext = context.length > 0;
+	const branch = theme.fg("dim", theme.tree.branch);
+	const last = theme.fg("dim", theme.tree.last);
+	const vertical = theme.fg("dim", theme.tree.vertical);
+
+	if (hasContext) {
+		lines.push(` ${branch} ${theme.fg("dim", "Context")}`);
+		for (const line of context.split("\n")) {
+			const content = line ? theme.fg("muted", line) : "";
+			lines.push(` ${vertical}  ${content}`);
+		}
+		lines.push(` ${last} ${theme.fg("dim", "Tasks")}: ${theme.fg("muted", `${args.tasks.length} agents`)}`);
+		return new Text(lines.join("\n"), 0, 0);
+	}
+
+	lines.push(`${theme.fg("dim", "Tasks")}: ${theme.fg("muted", `${args.tasks.length} agents`)}`);
+
+	return new Text(lines.join("\n"), 0, 0);
 }
 
 /**
@@ -278,8 +407,8 @@ function renderAgentProgress(
 	spinnerFrame?: number,
 ): string[] {
 	const lines: string[] = [];
-	const prefix = isLast ? theme.tree.last : theme.tree.branch;
-	const continuePrefix = isLast ? "   " : `${theme.tree.vertical}  `;
+	const prefix = isLast ? theme.fg("dim", theme.tree.last) : theme.fg("dim", theme.tree.branch);
+	const continuePrefix = isLast ? "   " : `${theme.fg("dim", theme.tree.vertical)}  `;
 
 	const icon = getStatusIcon(progress.status, theme, spinnerFrame);
 	const iconColor =
@@ -316,6 +445,8 @@ function renderAgentProgress(
 
 	lines.push(statusLine);
 
+	lines.push(...renderVarsSection(progress.vars, continuePrefix, expanded, theme));
+
 	// Current tool (if running) or most recent completed tool
 	if (progress.status === "running") {
 		if (progress.currentTool) {
@@ -498,8 +629,8 @@ function renderFindings(
  */
 function renderAgentResult(result: SingleResult, isLast: boolean, expanded: boolean, theme: Theme): string[] {
 	const lines: string[] = [];
-	const prefix = isLast ? theme.tree.last : theme.tree.branch;
-	const continuePrefix = isLast ? "   " : `${theme.tree.vertical}  `;
+	const prefix = isLast ? theme.fg("dim", theme.tree.last) : theme.fg("dim", theme.tree.branch);
+	const continuePrefix = isLast ? "   " : `${theme.fg("dim", theme.tree.vertical)}  `;
 
 	const aborted = result.aborted ?? false;
 	const success = !aborted && result.exitCode === 0;
@@ -525,6 +656,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	}
 
 	lines.push(statusLine);
+	lines.push(...renderVarsSection(result.vars, continuePrefix, expanded, theme));
 
 	// Check for review result (complete with review schema + report_finding)
 	const completeData = result.extractedToolData?.complete as Array<{ data: unknown }> | undefined;
@@ -634,7 +766,7 @@ export function renderResult(
 		const abortedCount = details.results.filter((r) => r.aborted).length;
 		const successCount = details.results.filter((r) => !r.aborted && r.exitCode === 0).length;
 		const failCount = details.results.length - successCount - abortedCount;
-		let summary = `\n${theme.fg("dim", "Total:")} `;
+		let summary = `${theme.fg("dim", "Total:")} `;
 		if (abortedCount > 0) {
 			summary += theme.fg("error", `${abortedCount} aborted`);
 			if (successCount > 0 || failCount > 0) summary += theme.sep.dot;
@@ -656,7 +788,8 @@ export function renderResult(
 		return new Text(theme.fg("dim", "No results"), 0, 0);
 	}
 
-	return new Text(lines.join("\n"), 0, 0);
+	const indented = lines.map((line) => (line.trim() ? `   ${line}` : ""));
+	return new Text(indented.join("\n"), 0, 0);
 }
 
 export const taskToolRenderer = {

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

@@ -0,0 +1,37 @@
+export function renderTemplate(template: string, vars: Record<string, string>): string {
+	return template.replace(/\{\{(\w+)\}\}/g, (_match, key: string) => vars[key] ?? `{{${key}}}`);
+}
+
+export function extractPlaceholders(template: string): string[] {
+	return [...template.matchAll(/\{\{(\w+)\}\}/g)].map((match) => match[1]);
+}
+
+export function validateTaskTemplate(
+	context: string | undefined,
+	tasks: Array<{ id: string; vars: Record<string, string> }>,
+): string | null {
+	const template = context ?? "";
+	const placeholders = extractPlaceholders(template);
+
+	if (tasks.length > 1 && placeholders.length === 0) {
+		return "Multi-task invocations require {{placeholders}} in context";
+	}
+
+	if (placeholders.length > 0) {
+		for (const task of tasks) {
+			const missing = placeholders.filter((placeholder) => !(placeholder in task.vars));
+			if (missing.length > 0) {
+				return `Task "${task.id}" missing vars: ${missing.join(", ")}`;
+			}
+		}
+	}
+
+	if (tasks.length > 1 && placeholders.length > 0) {
+		const withoutPlaceholders = template.replace(/\{\{\w+\}\}/g, "").trim();
+		if (withoutPlaceholders.length < 50) {
+			return "Context must contain instructions (50+ chars) around {{placeholders}}";
+		}
+	}
+
+	return null;
+}

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

@@ -46,8 +46,10 @@ export const taskItemSchema = Type.Object({
 		description: "Short task identifier for display (max 32 chars, CamelCase, e.g. 'SessionStore', 'WebFetchFix')",
 		maxLength: 32,
 	}),
-	task: Type.String({ description: "Task description for the agent" }),
 	description: Type.String({ description: "Short description for UI display" }),
+	vars: Type.Record(Type.String(), Type.String(), {
+		description: "Template variables to fill {{placeholders}} in context",
+	}),
 });
 
 export type TaskItem = Static<typeof taskItemSchema>;
@@ -55,7 +57,7 @@ export type TaskItem = Static<typeof taskItemSchema>;
 /** Task tool parameters */
 export const taskSchema = Type.Object({
 	agent: Type.String({ description: "Agent type to use for all tasks" }),
-	context: Type.String({ description: "Shared context prepended to all task prompts" }),
+	context: Type.String({ description: "Template with {{placeholders}} filled by task vars" }),
 	model: Type.Optional(
 		Type.String({
 			description: "Model override for all tasks (fuzzy matching, e.g. 'sonnet', 'opus')",
@@ -120,6 +122,7 @@ export interface AgentProgress {
 	agentSource: AgentSource;
 	status: "pending" | "running" | "completed" | "failed" | "aborted";
 	task: string;
+	vars?: Record<string, string>;
 	description?: string;
 	currentTool?: string;
 	currentToolArgs?: string;
@@ -141,6 +144,7 @@ export interface SingleResult {
 	agent: string;
 	agentSource: AgentSource;
 	task: string;
+	vars?: Record<string, string>;
 	description?: string;
 	exitCode: number;
 	output: string;

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

@@ -363,7 +363,7 @@ function createMCPProxyTool(metadata: MCPToolMetadata): CustomTool<TSchema> {
 }
 
 function getPythonCallTimeoutMs(params: PythonToolParams): number | undefined {
-	const timeout = params.timeout;
+	const timeout = params.timeoutMs;
 	if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0) {
 		return Math.max(1000, Math.round(timeout * 1000) + 1000);
 	}

package/src/index.ts

@@ -95,6 +95,8 @@ export type {
 	TurnStartEvent,
 	UserBashEvent,
 	UserBashEventResult,
+	UserPythonEvent,
+	UserPythonEventResult,
 } from "./core/extensions/index";
 // Extension types and utilities
 export {

package/src/main.ts

@@ -18,6 +18,7 @@ import { listModels } from "./cli/list-models";
 import { parsePluginArgs, printPluginHelp, runPluginCommand } from "./cli/plugin-cli";
 import { selectSession } from "./cli/session-picker";
 import { parseSetupArgs, printSetupHelp, runSetupCommand } from "./cli/setup-cli";
+import { parseStatsArgs, printStatsHelp, runStatsCommand } from "./cli/stats-cli";
 import { parseUpdateArgs, printUpdateHelp, runUpdateCommand } from "./cli/update-cli";
 import { findConfigFile, getModelsPath, VERSION } from "./config";
 import type { AgentSession } from "./core/agent-session";
@@ -520,6 +521,17 @@ export async function main(args: string[]) {
 		return;
 	}
 
+	// Handle stats subcommand
+	const statsCmd = parseStatsArgs(args);
+	if (statsCmd) {
+		if (args.includes("--help") || args.includes("-h")) {
+			printStatsHelp();
+			return;
+		}
+		await runStatsCommand(statsCmd);
+		return;
+	}
+
 	const parsed = parseArgs(args);
 	time("parseArgs");
 	await maybeAutoChdir(parsed);