@oh-my-pi/pi-coding-agent 15.10.12 → 15.11.1

package/src/task/output-manager.ts

@@ -85,15 +85,4 @@ export class AgentOutputManager {
 		await this.#ensureInitialized();
 		return this.#allocateUnique(id);
 	}
-
-	/**
-	 * Allocate unique IDs for a batch of tasks.
-	 *
-	 * @param ids Array of requested IDs
-	 * @returns Array of unique IDs in same order
-	 */
-	async allocateBatch(ids: string[]): Promise<string[]> {
-		await this.#ensureInitialized();
-		return ids.map(id => this.#allocateUnique(id));
-	}
 }

package/src/task/render.ts

@@ -62,6 +62,7 @@ function appendAgentStats(
 	line: string,
 	opts: {
 		toolCount?: number;
+		requests?: number;
 		tokens: number;
 		contextTokens?: number;
 		contextWindow?: number;
@@ -74,6 +75,9 @@ function appendAgentStats(
 	if (opts.toolCount) {
 		line += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(opts.toolCount)} ${theme.icon.extensionTool}`)}`;
 	}
+	if (opts.requests) {
+		line += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(opts.requests)} req`)}`;
+	}
 	// Current per-turn context — match the status line's `<pct>%/<window>` gauge (e.g. `5.1%/1M`).
 	if (opts.contextTokens && opts.contextTokens > 0) {
 		const ctx =
@@ -505,65 +509,106 @@ function formatOutputInline(data: unknown, theme: Theme, maxWidth = 80): string
 }
 
 /**
- * Render the per-task list (`id` + ui `description`) for the streaming call
- * preview. The args stream in token by token, so the array grows over time and
- * trailing entries may be partially parsed — every field access is defensive.
+ * Render the call preview lines for the single spawned agent. The
+ * args stream in token by token, so every field access is defensive.
  */
-function renderTaskItemLines(tasks: TaskItem[] | undefined, expanded: boolean, theme: Theme): string[] {
-	const items = tasks ?? [];
-	if (items.length === 0) return [];
-
+function renderTaskCallLines(args: Partial<TaskParams> | undefined, theme: Theme): string[] {
+	if (!args) return [];
 	const bullet = theme.fg("dim", "•");
-	const cap = expanded ? items.length : Math.min(items.length, 12);
-	const truncated = cap < items.length;
+	const lines: string[] = [];
+
+	const rawId = typeof args.id === "string" ? args.id.trim() : "";
+	const idLabel = rawId ? formatTaskId(rawId) : "";
+	const desc = typeof args.description === "string" ? args.description.trim() : "";
+	if (idLabel || desc) {
+		let line = `${bullet} ${theme.fg("accent", theme.bold(idLabel || "agent"))}`;
+		if (desc) {
+			line += `: ${theme.fg("muted", truncateToWidth(replaceTabs(desc), 64))}`;
+		}
+		lines.push(line);
+	}
+	lines.push(...renderTaskItemLines(args.tasks, theme));
+	return lines;
+}
+
+/**
+ * Render the per-item list (`id` + ui `description`) for a batch call's
+ * streaming preview. The args stream in token by token, so the array grows
+ * over time and trailing entries may be partially parsed — every field access
+ * is defensive.
+ */
+function renderTaskItemLines(tasks: TaskItem[] | undefined, theme: Theme): string[] {
+	if (!Array.isArray(tasks) || tasks.length === 0) return [];
 
+	const bullet = theme.fg("dim", "•");
+	const cap = Math.min(tasks.length, 12);
 	const lines: string[] = [];
 	for (let i = 0; i < cap; i++) {
-		const task = items[i] as Partial<TaskItem> | undefined;
-		const rawId = task?.id?.trim();
+		const task = tasks[i] as Partial<TaskItem> | undefined;
+		const rawId = typeof task?.id === "string" ? task.id.trim() : "";
 		const idLabel = rawId ? formatTaskId(rawId) : `#${i + 1}`;
 		let line = `${bullet} ${theme.fg("accent", theme.bold(idLabel))}`;
-		const desc = task?.description?.trim();
+		const desc = typeof task?.description === "string" ? task.description.trim() : "";
 		if (desc) {
 			line += `: ${theme.fg("muted", truncateToWidth(replaceTabs(desc), 64))}`;
 		}
+		if (task?.isolated === true) {
+			line += theme.fg("dim", " [isolated]");
+		}
 		lines.push(line);
 	}
-	if (truncated) {
-		lines.push(`${bullet} ${theme.fg("dim", formatMoreItems(items.length - cap, "agent"))}`);
+	if (cap < tasks.length) {
+		lines.push(`${bullet} ${theme.fg("dim", formatMoreItems(tasks.length - cap, "agent"))}`);
 	}
 	return lines;
 }
 
-/**
- * Build the shared-context section (the `# Goal / # Constraints` background
- * passed to every subagent). Rendered in both the streaming call preview and
- * the merged result frame so the brief stays visible for the whole task
- * lifecycle — not just until the first progress snapshot replaces the call view.
- */
-type TaskRenderSection = { lines: readonly string[] };
-type ContextSectionRenderer = (width: number) => TaskRenderSection;
+/** One renderable frame section: optional label, body rows, leading divider. */
+type TaskRenderSection = { label?: string; lines: readonly string[]; separator?: boolean };
+type AssignmentSectionRenderer = (width: number) => TaskRenderSection;
 
 // Default output-block layout is: left border + one-cell content inset + right
 // border. Render markdown at that inner width so the output block does not need
-// to rewrap already-rendered context lines.
-const CONTEXT_FRAME_INSET = 3;
+// to rewrap already-rendered assignment lines.
+const ASSIGNMENT_FRAME_INSET = 3;
 
-function contextMarkdownWidth(frameWidth: number): number {
-	return Math.max(1, frameWidth - CONTEXT_FRAME_INSET);
+/**
+ * Build the assignment section (the markdown brief handed to the subagent).
+ * Rendered in both the streaming call preview and the result frame so the
+ * brief stays visible for the whole task lifecycle — not just until the first
+ * progress snapshot replaces the call view.
+ */
+function createAssignmentSectionRenderer(
+	args: Partial<TaskParams> | undefined,
+	theme: Theme,
+): AssignmentSectionRenderer | undefined {
+	// `renderResult` receives the raw tool args (unlike `renderCall`, which is
+	// fed through `repairTaskParams`), so undo any per-field double-encoding
+	// here too. The repair is idempotent on already-clean text.
+	const assignment = repairDoubleEncodedJsonString(typeof args?.assignment === "string" ? args.assignment : "").trim();
+	if (!assignment) return undefined;
+	return createMarkdownSectionRenderer(assignment, theme);
 }
 
-function createContextSectionRenderer(args: TaskParams | undefined, theme: Theme): ContextSectionRenderer | undefined {
-	// `renderResult` receives the raw tool args (unlike `renderCall`, which is
-	// fed through `repairTaskParams`), so undo any per-field double-encoding here
-	// too. The repair is idempotent on already-clean text.
-	const context = repairDoubleEncodedJsonString(args?.context ?? "").trim();
+/**
+ * Build the shared-context section (the `# Goal / # Constraints` background a
+ * batch call hands every subagent). Rendered like the assignment brief so the
+ * shared background stays visible for the whole task lifecycle.
+ */
+function createContextSectionRenderer(
+	args: Partial<TaskParams> | undefined,
+	theme: Theme,
+): AssignmentSectionRenderer | undefined {
+	const context = repairDoubleEncodedJsonString(typeof args?.context === "string" ? args.context : "").trim();
 	if (!context) return undefined;
+	return createMarkdownSectionRenderer(context, theme);
+}
 
-	const markdown = new Markdown(context, 0, 0, getMarkdownTheme(), {
-		color: text => theme.fg("muted", text),
+function createMarkdownSectionRenderer(text: string, theme: Theme): AssignmentSectionRenderer {
+	const markdown = new Markdown(text, 0, 0, getMarkdownTheme(), {
+		color: line => theme.fg("muted", line),
 	});
-	return width => ({ lines: markdown.render(contextMarkdownWidth(width)) });
+	return width => ({ lines: markdown.render(Math.max(1, width - ASSIGNMENT_FRAME_INSET)) });
 }
 
 /**
@@ -576,21 +621,28 @@ export function renderCall(
 ): Component {
 	const showIsolated = "isolated" in args && args.isolated === true;
 	const header = renderStatusLine({ icon: "pending", title: "Task", description: args.agent }, theme);
-	const contextSectionRenderer = createContextSectionRenderer(args, theme);
+	const assignmentSection = createAssignmentSectionRenderer(args, theme);
+	const contextSection = createContextSectionRenderer(args, theme);
 	return framedBlock(theme, width => {
 		const sections: Array<{ label?: string; lines: readonly string[]; separator?: boolean }> = [];
 
-		if (contextSectionRenderer) sections.push(contextSectionRenderer(width));
-
-		// The per-task preview list only exists to surface dispatched agents while
-		// the call args stream in. Once a result snapshot exists, `renderResult`
-		// draws the same agents as progress/result lines, so showing the Tasks
-		// section here would just repeat the count the result frame already shows.
+		// The call preview only exists to surface the dispatched agent while the
+		// args stream in. Once a result snapshot exists, `renderResult` draws the
+		// same agent (and the assignment brief) itself, so showing it here would
+		// repeat what the result frame already shows.
 		if (!options.renderContext?.hasResult) {
-			sections.push({
-				separator: true,
-				lines: renderTaskItemLines(args.tasks, options.expanded, theme),
-			});
+			// Mirror renderResult's layout — context, assignment, then the
+			// per-agent list — so the agent rows do not jump from above the
+			// brief to below it when the first progress snapshot replaces the
+			// call view. This also matches the schema's field order (`context`
+			// streams before `tasks`), so the streaming preview grows
+			// append-only instead of inserting agent rows above the
+			// already-rendered markdown and pushing it down on every item.
+			if (contextSection) sections.push(contextSection(width));
+			if (assignmentSection) sections.push(assignmentSection(width));
+			const callLines = renderTaskCallLines(args, theme);
+			// Guarded: an empty trailing section would still draw its divider.
+			if (callLines.length > 0) sections.push({ separator: true, lines: callLines });
 		}
 
 		return {
@@ -631,8 +683,12 @@ function renderAgentProgress(
 	const titlePart = description ? `${theme.bold(displayId)}: ${description}` : displayId;
 	const indent = prefix ? `${prefix} ` : "";
 	let statusLine: string;
-	if (progress.status === "running") {
-		const bullet = theme.styledSymbol("status.done", "text");
+	if (progress.status === "running" || progress.status === "pending") {
+		// Live (or queued) agents shimmer their description so the row reads as
+		// in-flight even after the block freezes — the async spawn result keeps
+		// the agent on "pending" while the detached job runs.
+		const bullet =
+			progress.status === "running" ? theme.styledSymbol("status.done", "text") : theme.fg(iconColor, icon);
 		const name = theme.fg("accent", description ? theme.bold(displayId) : displayId);
 		statusLine = `${indent}${bullet} ${name}`;
 		if (description) {
@@ -945,6 +1001,7 @@ function renderAgentResult(
 		statusLine,
 		{
 			tokens: result.tokens,
+			requests: result.requests,
 			contextTokens: result.contextTokens,
 			contextWindow: result.contextWindow,
 			cost: result.usage?.cost.total ?? 0,
@@ -1073,9 +1130,11 @@ function renderAgentResult(
 }
 
 /**
- * Order live progress entries so finished agents render first and unfinished
- * (pending/running) ones stay pinned at the bottom as tasks complete. Stable
- * within each group, so agents keep their dispatch order.
+ * Order live progress entries so finished agents render first — sorted by
+ * runtime ascending, matching {@link orderResultsForDisplay} — while
+ * unfinished (pending/running) ones stay pinned at the bottom in dispatch
+ * order. Because a finished agent's runtime is fixed, finalization renders
+ * the same order and rows never reshuffle.
  */
 function orderProgressForDisplay(progress: readonly AgentProgress[]): AgentProgress[] {
 	const finished: AgentProgress[] = [];
@@ -1083,9 +1142,19 @@ function orderProgressForDisplay(progress: readonly AgentProgress[]): AgentProgr
 	for (const p of progress) {
 		(p.status === "pending" || p.status === "running" ? unfinished : finished).push(p);
 	}
+	finished.sort((a, b) => a.durationMs - b.durationMs || a.index - b.index);
 	return finished.concat(unfinished);
 }
 
+/**
+ * Order finalized results by runtime ascending (tie-break: dispatch index) so
+ * the finalized list matches the live-progress order produced by
+ * {@link orderProgressForDisplay}.
+ */
+function orderResultsForDisplay(results: readonly SingleResult[]): SingleResult[] {
+	return [...results].sort((a, b) => a.durationMs - b.durationMs || a.index - b.index);
+}
+
 /**
  * Render the tool result.
  */
@@ -1097,25 +1166,28 @@ export function renderResult(
 ): Component {
 	const fallbackText = result.content.find(c => c.type === "text")?.text ?? "";
 	const details = result.details;
-	const contextSectionRenderer = createContextSectionRenderer(args, theme);
+	const agentLabel = args?.agent?.trim() || undefined;
+	const assignmentSection = createAssignmentSectionRenderer(args, theme);
+	const contextSection = createContextSectionRenderer(args, theme);
 
 	if (!details) {
 		const text = result.content.find(c => c.type === "text")?.text || "";
 		const errored = result.isError === true;
 		const header = errored
-			? renderStatusLine({ icon: "error", title: "Task", description: args?.agent }, theme)
+			? renderStatusLine({ icon: "error", title: "Task", description: agentLabel }, theme)
 			: renderStatusLine(
 					{
 						iconOverride: theme.styledSymbol("status.done", "accent"),
 						title: "Task",
-						description: args?.agent,
+						description: agentLabel,
 					},
 					theme,
 				);
 		return framedBlock(theme, width => ({
 			header,
 			sections: [
-				...(contextSectionRenderer ? [contextSectionRenderer(width)] : []),
+				...(contextSection ? [contextSection(width)] : []),
+				...(assignmentSection ? [assignmentSection(width)] : []),
 				...(text ? [{ separator: true, lines: [theme.fg("dim", truncateToWidth(text, width))] }] : []),
 			],
 			state: errored ? "error" : "success",
@@ -1131,12 +1203,10 @@ export function renderResult(
 	const isError = aborted || failed;
 	const agentCount = hasResults ? details.results.length : (details.progress?.length ?? 0);
 	const icon: ToolUIStatus = options.isPartial ? "running" : isError ? "error" : mergeFailed ? "warning" : "success";
-	// Surface the dispatched agent type (e.g. `Reviewer`) alongside the count so
-	// the header reads `Task 16 agents: Reviewer`. All tasks in one call share a
-	// single `agent` type (top-level param), so one label covers the whole batch.
-	const agentName = args?.agent?.trim();
+	// Surface the dispatched agent type (e.g. `Reviewer`) alongside the count
+	// so the header reads `Task 1 agent: Reviewer`.
 	const countLabel = agentCount > 0 ? `${agentCount} ${agentCount === 1 ? "agent" : "agents"}` : undefined;
-	const metaLabel = countLabel ? (agentName ? `${countLabel}: ${agentName}` : countLabel) : agentName;
+	const metaLabel = countLabel ? (agentLabel ? `${countLabel}: ${agentLabel}` : countLabel) : agentLabel;
 	const header = renderStatusLine(
 		{
 			icon: icon === "success" ? undefined : icon,
@@ -1158,7 +1228,7 @@ export function renderResult(
 				lines.push(...renderAgentProgress(progress, "", "  ", expanded, theme, spinnerFrame));
 			});
 		} else if (details.results && details.results.length > 0) {
-			details.results.forEach(res => {
+			orderResultsForDisplay(details.results).forEach(res => {
 				lines.push(...renderAgentResult(res, "", "  ", expanded, theme));
 			});
 
@@ -1171,6 +1241,8 @@ export function renderResult(
 			if (successCount > 0) summaryParts.push(theme.fg("success", `${successCount} succeeded`));
 			if (mergeFailedCount > 0) summaryParts.push(theme.fg("warning", `${mergeFailedCount} merge failed`));
 			if (failCount > 0) summaryParts.push(theme.fg("error", `${failCount} failed`));
+			const totalRequests = details.results.reduce((sum, r) => sum + (r.requests ?? 0), 0);
+			if (totalRequests > 0) summaryParts.push(theme.fg("dim", `${formatNumber(totalRequests)} req`));
 			summaryParts.push(theme.fg("dim", formatDuration(details.totalDurationMs)));
 			// Wrap the run summary in the theme's bracket glyphs (dim chrome, colored
 			// counts) to match the bash tool's `[Wall: … | Exit: …]` footer.
@@ -1189,7 +1261,8 @@ export function renderResult(
 			return {
 				header,
 				sections: [
-					...(contextSectionRenderer ? [contextSectionRenderer(width)] : []),
+					...(contextSection ? [contextSection(width)] : []),
+					...(assignmentSection ? [assignmentSection(width)] : []),
 					{ separator: true, lines: [theme.fg("dim", truncateToWidth(text, width))] },
 				],
 				state,
@@ -1219,7 +1292,8 @@ export function renderResult(
 		return {
 			header,
 			sections: [
-				...(contextSectionRenderer ? [contextSectionRenderer(width)] : []),
+				...(contextSection ? [contextSection(width)] : []),
+				...(assignmentSection ? [assignmentSection(width)] : []),
 				...(lines.length > 0 ? [{ separator: true, lines }] : []),
 			],
 			state,
@@ -1252,8 +1326,9 @@ function renderNestedTaskResults(detailsList: TaskToolDetails[], expanded: boole
 	const lines: string[] = [];
 	for (const details of detailsList) {
 		if (!details.results || details.results.length === 0) continue;
-		details.results.forEach((result, index) => {
-			const { prefix, continuePrefix } = nestedMarkers(index === details.results.length - 1, theme);
+		const ordered = orderResultsForDisplay(details.results);
+		ordered.forEach((result, index) => {
+			const { prefix, continuePrefix } = nestedMarkers(index === ordered.length - 1, theme);
 			lines.push(...renderAgentResult(result, prefix, continuePrefix, expanded, theme));
 		});
 	}
@@ -1275,8 +1350,9 @@ function renderNestedTaskTree(
 	for (const details of detailsList) {
 		const hasResults = Boolean(details.results && details.results.length > 0);
 		if (hasResults) {
-			details.results.forEach((result, index) => {
-				const { prefix, continuePrefix } = nestedMarkers(index === details.results.length - 1, theme);
+			const ordered = orderResultsForDisplay(details.results);
+			ordered.forEach((result, index) => {
+				const { prefix, continuePrefix } = nestedMarkers(index === ordered.length - 1, theme);
 				lines.push(...renderAgentResult(result, prefix, continuePrefix, expanded, theme));
 			});
 			continue;

package/src/task/repair-args.ts

@@ -2,7 +2,7 @@
  * Repair double-encoded JSON string arguments for the task tool.
  *
  * Models occasionally JSON-escape a string value twice when emitting a
- * `task` tool call, so a `context`/`assignment` that should read
+ * `task` tool call, so an `assignment` that should read
  *
  *     # Role
  *     You are a judge … "describe this" … return —
@@ -24,7 +24,7 @@
  * string.
  *
  * This is deliberately scoped to the task tool's natural-language fields
- * (`context`, `assignment`, `description`). It is NOT applied to code-bearing
+ * (`assignment`, `description`). It is NOT applied to code-bearing
  * tools (write/edit/bash/search), where a backslash or quote is load-bearing
  * and a false-positive unescape would silently corrupt a file or command.
  */
@@ -90,15 +90,20 @@ function repairTaskItem(task: TaskItem): TaskItem {
 }
 
 /**
- * Repair double-encoded prose in task-tool params (`context` and each task's
- * `assignment`/`description`). Returns the same reference when nothing changed
- * so callers can cheaply skip work. Defensive against partially-streamed args
- * (missing/undefined fields, partial task arrays) so it is safe on the render
- * path as well as on execution.
+ * Repair double-encoded prose in task-tool params (`assignment`,
+ * `description`, shared `context`, and each batch task item's prose fields).
+ * Returns the same reference when nothing changed so callers can cheaply skip
+ * work. Defensive against partially-streamed args (missing/undefined fields,
+ * partial task arrays) so it is safe on the render path as well as on
+ * execution.
  */
 export function repairTaskParams(params: TaskParams): TaskParams {
 	if (params === null || typeof params !== "object") return params;
 
+	const assignment =
+		typeof params.assignment === "string" ? repairDoubleEncodedJsonString(params.assignment) : params.assignment;
+	const description =
+		typeof params.description === "string" ? repairDoubleEncodedJsonString(params.description) : params.description;
 	const context = typeof params.context === "string" ? repairDoubleEncodedJsonString(params.context) : params.context;
 
 	let tasks = params.tasks;
@@ -112,6 +117,13 @@ export function repairTaskParams(params: TaskParams): TaskParams {
 		if (changed) tasks = repaired;
 	}
 
-	if (context === params.context && tasks === params.tasks) return params;
-	return { ...params, context, tasks };
+	if (
+		assignment === params.assignment &&
+		description === params.description &&
+		context === params.context &&
+		tasks === params.tasks
+	) {
+		return params;
+	}
+	return { ...params, assignment, description, context, tasks };
 }

package/src/task/types.ts

@@ -3,7 +3,6 @@ import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import type { AgentSessionEvent } from "../session/agent-session";
-import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
 import type { NestedRepoPatch } from "./worktree";
 
 /** Source of an agent definition */
@@ -66,84 +65,88 @@ export interface SubagentLifecyclePayload {
 	index: number;
 }
 
-const assignmentDescription = "per-task instructions; self-contained";
-
-const createTaskItemSchema = (_contextEnabled: boolean) =>
-	z.object({
-		id: z.string().max(48).describe("camelcase identifier"),
-		description: z.string().describe("ui label, not seen by subagent"),
-		assignment: z.string().describe(assignmentDescription),
-	});
-
-/** Single task item for parallel execution (default shape with context enabled). */
-export const taskItemSchema = createTaskItemSchema(true);
-export type TaskItem = z.infer<typeof taskItemSchema>;
-
-const createTaskSchema = (options: { isolationEnabled: boolean; simpleMode: TaskSimpleMode }) => {
-	const { contextEnabled, customSchemaEnabled } = getTaskSimpleModeCapabilities(options.simpleMode);
-	const itemSchema = createTaskItemSchema(contextEnabled);
-
-	let schema = z.object({
-		agent: z.string().describe("agent type"),
-		tasks: z.array(itemSchema).describe("tasks to execute in parallel"),
-	});
-	if (contextEnabled) {
-		schema = schema.extend({
-			context: z.string().optional().describe("shared background prepended to each assignment"),
-		});
-	}
-
-	if (customSchemaEnabled) {
-		schema = schema.extend({
-			schema: z.string().optional().describe("jtd schema for expected response shape"),
-		});
-	}
+/**
+ * One unit of work. The single-spawn schema is `{ agent, ...taskItemSchema }`;
+ * the batch schema (`task.batch`) is `{ agent, context, tasks: taskItemSchema[] }`.
+ * When task isolation is enabled, `isolated` joins the item shape (per-item in
+ * batch form, top-level in the flat form via the spread).
+ */
+const taskItemShape = {
+	id: z.string().max(48).optional().describe("stable agent id; default generated"),
+	description: z.string().optional().describe("ui label, not seen by subagent"),
+	assignment: z.string().describe("the work; self-contained instructions"),
+};
+const isolatedShape = {
+	isolated: z.boolean().optional().describe("run in isolated env; returns patches"),
+};
+const agentShape = {
+	agent: z.string().describe("agent type to spawn"),
+};
+const contextShape = {
+	context: z.string().describe("shared background prepended to each assignment"),
+};
 
-	if (options.isolationEnabled) {
-		schema = schema.extend({
-			isolated: z.boolean().optional().describe("run in isolated env; returns patches"),
-		});
-	}
+export const taskItemSchema = z.object(taskItemShape);
+const taskItemSchemaIsolated = z.object({ ...taskItemShape, ...isolatedShape });
 
-	return schema;
-};
+/** Single task item. Fields are optional defensively: args stream in token by token. */
+export interface TaskItem {
+	/** Stable agent id; default = generated AdjectiveNoun. */
+	id?: string;
+	/** UI label, not seen by the subagent. */
+	description?: string;
+	/** The work; required by the schema. */
+	assignment?: string;
+	/** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
+	isolated?: boolean;
+}
 
-export const taskSchema = createTaskSchema({ isolationEnabled: true, simpleMode: "default" });
-export const taskSchemaNoIsolation = createTaskSchema({ isolationEnabled: false, simpleMode: "default" });
-const taskSchemaSchemaFree = createTaskSchema({ isolationEnabled: true, simpleMode: "schema-free" });
-const taskSchemaSchemaFreeNoIsolation = createTaskSchema({ isolationEnabled: false, simpleMode: "schema-free" });
-const taskSchemaIndependent = createTaskSchema({ isolationEnabled: true, simpleMode: "independent" });
-const taskSchemaIndependentNoIsolation = createTaskSchema({ isolationEnabled: false, simpleMode: "independent" });
-const ALL_TASK_SCHEMAS = [
-	taskSchema,
-	taskSchemaNoIsolation,
-	taskSchemaSchemaFree,
-	taskSchemaSchemaFreeNoIsolation,
-	taskSchemaIndependent,
-	taskSchemaIndependentNoIsolation,
-] as const;
+export const taskSchema = z.object({ ...agentShape, ...taskItemShape, ...isolatedShape });
+const taskSchemaNoIsolation = z.object({ ...agentShape, ...taskItemShape });
+const taskSchemaBatch = z.object({
+	...agentShape,
+	...contextShape,
+	tasks: z.array(taskItemSchemaIsolated).describe("tasks to spawn; one subagent per item"),
+});
+const taskSchemaBatchNoIsolation = z.object({
+	...agentShape,
+	...contextShape,
+	tasks: z.array(taskItemSchema).describe("tasks to spawn; one subagent per item"),
+});
+const ALL_TASK_SCHEMAS = [taskSchema, taskSchemaNoIsolation, taskSchemaBatch, taskSchemaBatchNoIsolation] as const;
 
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
 export type TaskSchema = typeof taskSchema;
-/** Active task tool parameter schema for the current simple-mode / isolation flags */
+/** Active task tool parameter schema for the current isolation / batch flags */
 export type TaskToolSchemaInstance = DynamicTaskSchema;
 
-export function getTaskSchema(options: { isolationEnabled: boolean; simpleMode: TaskSimpleMode }): DynamicTaskSchema {
-	switch (options.simpleMode) {
-		case "schema-free":
-			return options.isolationEnabled ? taskSchemaSchemaFree : taskSchemaSchemaFreeNoIsolation;
-		case "independent":
-			return options.isolationEnabled ? taskSchemaIndependent : taskSchemaIndependentNoIsolation;
-		default:
-			return options.isolationEnabled ? taskSchema : taskSchemaNoIsolation;
+export function getTaskSchema(options: { isolationEnabled: boolean; batchEnabled: boolean }): DynamicTaskSchema {
+	if (options.batchEnabled) {
+		return options.isolationEnabled ? taskSchemaBatch : taskSchemaBatchNoIsolation;
 	}
+	return options.isolationEnabled ? taskSchema : taskSchemaNoIsolation;
 }
 
+/**
+ * Runtime params union over both wire shapes. The model sees exactly one shape
+ * (`{ agent, context, tasks[] }` when `task.batch` is on, `{ agent, ...item }`
+ * otherwise); runtime stays permissive so internal callers and stale
+ * transcripts using the flat form keep working under either setting.
+ */
 export interface TaskParams {
-	agent: string;
+	/** Agent type; required. */
+	agent?: string;
+	/** Stable agent id (flat form); default = generated AdjectiveNoun. */
+	id?: string;
+	/** UI label (flat form), not seen by the subagent. */
+	description?: string;
+	/** The work (flat form). */
+	assignment?: string;
+	/** Batch form (`task.batch`): one subagent per item. */
+	tasks?: TaskItem[];
+	/** Batch form: shared background prepended to every assignment; required by the batch schema. */
 	context?: string;
-	schema?: string;
-	tasks: TaskItem[];
+	/** Run in an isolated worktree (flat form; per-item in batch form). */
 	isolated?: boolean;
 }
 
@@ -206,6 +209,8 @@ export interface AgentProgress {
 	recentTools: Array<{ tool: string; args: string; endMs: number }>;
 	recentOutput: string[];
 	toolCount: number;
+	/** Count of assistant requests (assistant message_end events) across the run. Drives the soft request budget guard. */
+	requests: number;
 	/** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
 	tokens: number;
 	/**
@@ -276,6 +281,8 @@ export interface SingleResult {
 	durationMs: number;
 	/** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
 	tokens: number;
+	/** Count of assistant requests (assistant message_end events) across the run. */
+	requests: number;
 	/** Latest per-turn context size at task completion. See `AgentProgress.contextTokens`. */
 	contextTokens?: number;
 	/** Model's context window in tokens, when known. */

package/src/tools/ask.ts

@@ -104,7 +104,7 @@ const RECOMMENDED_SUFFIX = " (Recommended)";
 const TIMEOUT_DETECTION_TOLERANCE_MS = 1_000;
 
 function getDoneOptionLabel(): string {
-	return `${theme.symbol("tool.ask")} Done selecting`;
+	return `${theme.status.success} Done selecting`;
 }
 
 /** Add "(Recommended)" suffix to the option at the given index if not already present */
@@ -694,7 +694,9 @@ function normalizeRenderQuestions(raw: unknown): NonNullable<AskRenderArgs["ques
 /** Render a custom free-text answer as a status line plus indented continuation rows. */
 function renderCustomInputLines(uiTheme: Theme, customInput: string): string[] {
 	const lines = customInput.split("\n");
-	const out: string[] = [` ${uiTheme.styledSymbol("tool.ask", "accent")} ${uiTheme.fg("toolOutput", lines[0] ?? "")}`];
+	const out: string[] = [
+		` ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", lines[0] ?? "")}`,
+	];
 	for (let i = 1; i < lines.length; i++) out.push(`   ${uiTheme.fg("toolOutput", lines[i])}`);
 	return out;
 }