@oh-my-pi/pi-coding-agent 16.4.4 → 16.4.6

package/src/task/label.ts

@@ -0,0 +1,38 @@
+/**
+ * Tiny-model UI labels for spawned subagents.
+ */
+import { logger, prompt } from "@oh-my-pi/pi-utils";
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+import taskLabelSystemPrompt from "../prompts/system/task-label.md" with { type: "text" };
+import { generateSessionTitle } from "../utils/title-generator";
+
+const TASK_LABEL_SYSTEM_PROMPT = prompt.render(taskLabelSystemPrompt);
+
+/** Compresses a delegated assignment into a one-sentence UI label via the tiny title model — fired by the executor spawn path because the task wire schema no longer carries a `description`; null on empty input or failure. */
+export async function generateTaskLabel(
+	assignment: string,
+	registry: ModelRegistry,
+	settings: Settings,
+	sessionId?: string,
+): Promise<string | null> {
+	const text = assignment.trim();
+	if (!text) return null;
+	try {
+		return await generateSessionTitle(
+			text,
+			registry,
+			settings,
+			sessionId,
+			undefined,
+			undefined,
+			TASK_LABEL_SYSTEM_PROMPT,
+		);
+	} catch (err) {
+		logger.debug("task-label: generation failed", {
+			sessionId,
+			error: err instanceof Error ? err.message : String(err),
+		});
+		return null;
+	}
+}

package/src/task/render.ts

@@ -677,6 +677,35 @@ function formatOutputInline(data: unknown, theme: Theme, maxWidth = 80): string
 	return `Output: ${pairs.join(", ")}`;
 }
 
+/**
+ * First line of a streamed `task` brief, trimmed — a row's secondary text.
+ * The args stream in token by token, so non-string values fall through to "".
+ */
+function taskFirstLine(task: unknown): string {
+	if (typeof task !== "string") return "";
+	const trimmed = task.trim();
+	const newline = trimmed.indexOf("\n");
+	return newline === -1 ? trimmed : trimmed.slice(0, newline);
+}
+
+/**
+ * Header label for a task call while nothing has spawned yet: the flat form's
+ * `agent` type. Batch calls return undefined — each item row carries its own
+ * `⟨agent⟩` badge, so a joined list in the header would just repeat them.
+ */
+function formatAgentHeaderLabel(args: Partial<TaskParams> | undefined): string | undefined {
+	if (!args) return undefined;
+	const flat = typeof args.agent === "string" ? args.agent.trim() : "";
+	return flat || undefined;
+}
+
+/** Dim `⟨agent⟩` badge for a non-default agent type; empty for the generic worker. */
+function agentTypeBadge(agent: string | undefined, theme: Theme): string {
+	const trimmed = agent?.trim();
+	if (!trimmed || trimmed === "task") return "";
+	return ` ${theme.fg("dim", `${theme.format.bracketLeft}${trimmed}${theme.format.bracketRight}`)}`;
+}
+
 /**
  * Render the call preview lines for the single spawned agent. The
  * args stream in token by token, so every field access is defensive.
@@ -686,14 +715,15 @@ function renderTaskCallLines(args: Partial<TaskParams> | undefined, theme: Theme
 	const bullet = theme.fg("dim", "•");
 	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) {
+	const rawName = typeof args.name === "string" ? args.name.trim() : "";
+	const idLabel = rawName ? formatTaskId(rawName) : "";
+	const brief = taskFirstLine(args.task);
+	if (idLabel || brief) {
 		let line = `${bullet} ${theme.fg("accent", theme.bold(idLabel || "agent"))}`;
-		if (desc) {
-			line += `: ${theme.fg("muted", previewLine(desc, 64))}`;
+		if (brief) {
+			line += `: ${theme.fg("muted", previewLine(brief, 64))}`;
 		}
+		line += agentTypeBadge(args.agent, theme);
 		lines.push(line);
 	}
 	lines.push(...renderTaskItemLines(args.tasks, theme));
@@ -707,7 +737,7 @@ function renderTaskCallLines(args: Partial<TaskParams> | undefined, theme: Theme
 const COLLAPSED_AGENT_LIMIT = 4;
 
 /**
- * Render the per-item list (`id` + ui `description`) for a batch call's
+ * Render the per-item list (`name` + `task` brief) 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.
@@ -719,15 +749,16 @@ function renderTaskItemLines(tasks: TaskItem[] | undefined, theme: Theme): strin
 	const cap = Math.min(tasks.length, COLLAPSED_AGENT_LIMIT);
 	const lines: string[] = [];
 	for (let i = 0; i < cap; i++) {
-		const task = tasks[i] as Partial<TaskItem> | undefined;
-		const rawId = typeof task?.id === "string" ? task.id.trim() : "";
-		const idLabel = rawId ? formatTaskId(rawId) : `#${i + 1}`;
+		const item = tasks[i] as Partial<TaskItem> | undefined;
+		const rawName = typeof item?.name === "string" ? item.name.trim() : "";
+		const idLabel = rawName ? formatTaskId(rawName) : `#${i + 1}`;
 		let line = `${bullet} ${theme.fg("accent", theme.bold(idLabel))}`;
-		const desc = typeof task?.description === "string" ? task.description.trim() : "";
-		if (desc) {
-			line += `: ${theme.fg("muted", previewLine(desc, 64))}`;
+		const brief = taskFirstLine(item?.task);
+		if (brief) {
+			line += `: ${theme.fg("muted", previewLine(brief, 64))}`;
 		}
-		if (task?.isolated === true) {
+		line += agentTypeBadge(item?.agent, theme);
+		if (item?.isolated === true) {
 			line += theme.fg("dim", " [isolated]");
 		}
 		lines.push(line);
@@ -760,7 +791,7 @@ function createAssignmentSectionRenderer(
 	// `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();
+	const assignment = repairDoubleEncodedJsonString(typeof args?.task === "string" ? args.task : "").trim();
 	if (!assignment) return undefined;
 	return createMarkdownSectionRenderer(assignment, theme);
 }
@@ -795,7 +826,11 @@ export function renderCall(args: TaskParams, options: TaskRenderOptions, theme:
 	// pending/hourglass icon would misread the call as something the turn
 	// waits on.
 	const header = renderStatusLine(
-		{ iconOverride: theme.styledSymbol("tool.task", "accent"), title: "Task", description: args.agent },
+		{
+			iconOverride: theme.styledSymbol("tool.task", "accent"),
+			title: "Task",
+			description: formatAgentHeaderLabel(args),
+		},
 		theme,
 	);
 	const assignmentSection = createAssignmentSectionRenderer(args, theme);
@@ -883,6 +918,7 @@ function renderAgentProgress(
 	} else {
 		statusLine = `${indent}${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)}`;
 	}
+	statusLine += agentTypeBadge(progress.agent, theme);
 
 	// Show retry-blocked badge so the parent immediately sees that a child
 	// is sleeping on a provider 429, not silently progressing. Wins over the
@@ -1215,7 +1251,7 @@ function renderAgentResult(
 	let statusLine = `${prefix ? `${prefix} ` : ""}${theme.fg(iconColor, icon)} ${theme.fg(
 		success && !needsWarning ? "text" : "accent",
 		titlePart,
-	)} ${formatBadge(statusText, iconColor, theme)}`;
+	)}${agentTypeBadge(result.agent, theme)} ${formatBadge(statusText, iconColor, theme)}`;
 	const showBadge = settings.get("task.showResolvedModelBadge");
 	statusLine = appendAgentStats(
 		statusLine,
@@ -1460,7 +1496,7 @@ export function renderResult(
 ): Component {
 	const fallbackText = result.content.find(c => c.type === "text")?.text ?? "";
 	const details = result.details;
-	const agentLabel = args?.agent?.trim() || undefined;
+	const agentLabel = formatAgentHeaderLabel(args);
 	const assignmentSection = createAssignmentSectionRenderer(args, theme);
 	const contextSection = createContextSectionRenderer(args, theme);
 
@@ -1515,10 +1551,11 @@ 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 1 agent: Reviewer`.
+	// Header meta is the spawn count only; each row carries its own ⟨agent⟩
+	// badge, so a joined type list here would repeat them. Before anything
+	// spawns, fall back to the flat form's agent type from the call args.
 	const countLabel = agentCount > 0 ? `${agentCount} ${agentCount === 1 ? "agent" : "agents"}` : undefined;
-	const metaLabel = countLabel ? (agentLabel ? `${countLabel}: ${agentLabel}` : countLabel) : agentLabel;
+	const metaLabel = countLabel ?? agentLabel;
 	const header = renderStatusLine(
 		{
 			icon: icon === "success" || icon === "running" ? undefined : icon,
@@ -1542,8 +1579,10 @@ export function renderResult(
 		const frozen = options.renderContext?.frozen === true;
 		const lines: string[] = [];
 
+		// Result rows win once any exist; progress rows for spawns without a
+		// result (a mixed call's async subset) render as a supplement below.
 		const shouldRenderProgress =
-			Boolean(details.progress && details.progress.length > 0) && (isPartial || details.results.length === 0);
+			Boolean(details.progress && details.progress.length > 0) && details.results.length === 0;
 		if (shouldRenderProgress && details.progress) {
 			const ordered = orderProgressForDisplay(details.progress);
 			// Collapsed view keeps the live edge: finished rows sort to the top of
@@ -1570,6 +1609,19 @@ export function renderResult(
 				);
 			}
 
+			// Mixed blocking+async call: async spawns never land in `results`
+			// (their payloads deliver through jobs) — keep their rows visible
+			// beside the finalized inline results, live while running and
+			// settled once their jobs finish.
+			const supplementalProgress = details.progress
+				? orderProgressForDisplay(
+						details.progress.filter(progress => !details.results.some(res => res.id === progress.id)),
+					)
+				: [];
+			for (const progress of supplementalProgress) {
+				lines.push(...renderAgentProgress(progress, "", "  ", expanded, theme, spinnerFrame, frozen));
+			}
+
 			const summaryParts: string[] = [];
 			if (abortedCount > 0) summaryParts.push(theme.fg("error", `${abortedCount} aborted`));
 			if (successCount > 0) summaryParts.push(theme.fg("success", `${successCount} succeeded`));

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 an `assignment` that should read
+ * `task` tool call, so a `task` field that should read
  *
  *     # Role
  *     You are a judge … "describe this" … return —
@@ -24,7 +24,8 @@
  * string.
  *
  * This is deliberately scoped to the task tool's natural-language fields
- * (`assignment`, `description`). It is NOT applied to code-bearing
+ * (`task`, shared `context`); identifier fields (`name`, `agent`)
+ * are never repaired. 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.
  */
@@ -78,52 +79,40 @@ export function repairDoubleEncodedJsonString(value: string): string {
 	return typeof decoded === "string" && decoded !== value ? decoded : value;
 }
 
-/** Repair a single (possibly partial) task item's prose fields. */
-function repairTaskItem(task: TaskItem): TaskItem {
-	if (task === null || typeof task !== "object") return task;
-	const assignment =
-		typeof task.assignment === "string" ? repairDoubleEncodedJsonString(task.assignment) : task.assignment;
-	const description =
-		typeof task.description === "string" ? repairDoubleEncodedJsonString(task.description) : task.description;
-	if (assignment === task.assignment && description === task.description) return task;
-	return { ...task, assignment, description };
+/** Repair a single (possibly partial) task item's prose field (`task`). */
+function repairTaskItem(item: TaskItem): TaskItem {
+	if (item === null || typeof item !== "object") return item;
+	const task = typeof item.task === "string" ? repairDoubleEncodedJsonString(item.task) : item.task;
+	if (task === item.task) return item;
+	return { ...item, task };
 }
 
 /**
- * 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.
+ * Repair double-encoded prose in task-tool params (flat `task`, shared
+ * `context`, and each batch task item's `task`). 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 task = typeof params.task === "string" ? repairDoubleEncodedJsonString(params.task) : params.task;
 	const context = typeof params.context === "string" ? repairDoubleEncodedJsonString(params.context) : params.context;
 
 	let tasks = params.tasks;
 	if (Array.isArray(params.tasks)) {
 		let changed = false;
-		const repaired = params.tasks.map(task => {
-			const next = repairTaskItem(task);
-			if (next !== task) changed = true;
+		const repaired = params.tasks.map(item => {
+			const next = repairTaskItem(item);
+			if (next !== item) changed = true;
 			return next;
 		});
 		if (changed) tasks = repaired;
 	}
 
-	if (
-		assignment === params.assignment &&
-		description === params.description &&
-		context === params.context &&
-		tasks === params.tasks
-	) {
+	if (task === params.task && context === params.context && tasks === params.tasks) {
 		return params;
 	}
-	return { ...params, assignment, description, context, tasks };
+	return { ...params, task, context, tasks };
 }

package/src/task/spawn-policy.test.ts

@@ -42,9 +42,9 @@ describe("task spawn policy surfaces", () => {
 
 	it("uses the first allowed spawn as the schema default", () => {
 		const schema = getTaskSchema({ isolationEnabled: false, batchEnabled: false, defaultAgent: "fact-finder" });
-		const parsed = schema({ assignment: "check" });
+		const parsed = schema({ task: "check" });
 
-		expect(parsed).toEqual({ agent: "fact-finder", assignment: "check" });
+		expect(parsed).toEqual({ agent: "fact-finder", task: "check" });
 	});
 
 	it("renders the restricted spawn default in the task description", async () => {
@@ -56,8 +56,8 @@ describe("task spawn policy surfaces", () => {
 		const tool = await TaskTool.create(makeSession("fact-finder,oracle"));
 		const description = tool.description;
 
-		expect(description).toContain("Defaults to `fact-finder`");
+		expect(description).toContain("the general-purpose worker (`fact-finder`)");
 		expect(description).toContain("Current spawn policy allows: `fact-finder`, `oracle`.");
-		expect(description).not.toContain("Defaults to `task`");
+		expect(description).not.toContain("(`task`)");
 	});
 });

package/src/task/types.ts

@@ -1,8 +1,8 @@
-import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
 import { type BaseType, type } from "arktype";
 import type { AgentSessionEvent } from "../session/agent-session";
+import type { ConfiguredThinkingLevel } from "../thinking";
 import type { NestedRepoPatch } from "./worktree";
 
 /** Source of an agent definition */
@@ -75,66 +75,53 @@ export interface SubagentLifecyclePayload {
 }
 
 /** Display cap for a normalized one-line label (roster line, registry `displayName`, prompt field). */
-export const ROLE_LABEL_MAX = 80;
-/** Schema bound on the raw `role` input, before it is label-normalized at every use site. */
-export const ROLE_INPUT_MAX = 256;
-const ROLE_INPUT_SCHEMA = `string <= ${ROLE_INPUT_MAX}` as const;
+export const LABEL_MAX = 80;
 
 export const taskItemSchema = type({
-	"id?": "string",
-	"description?": "string",
-	"role?": ROLE_INPUT_SCHEMA,
-	assignment: "string",
+	"name?": "string",
+	agent: "string = 'task'",
+	task: "string",
 	"+": "delete",
 });
 const taskItemSchemaIsolated = type({
-	"id?": "string",
-	"description?": "string",
-	"role?": ROLE_INPUT_SCHEMA,
-	assignment: "string",
+	"name?": "string",
+	agent: "string = 'task'",
+	task: "string",
 	"isolated?": "boolean",
 	"+": "delete",
 });
 
 /** 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;
-	/** Specialist role/expertise this subagent embodies; shapes its system-prompt identity and display name. */
-	role?: string;
+	/** Stable agent name; becomes the registry/IRC id. Default = generated AdjectiveNoun. */
+	name?: string;
+	/** Agent type to run this item (e.g. "scout"). Defaults to the spawn policy's default agent. */
+	agent?: string;
 	/** The work; required by the schema. */
-	assignment?: string;
+	task?: string;
 	/** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
 	isolated?: boolean;
 }
 
 export const taskSchema = type({
+	"name?": "string",
 	agent: "string = 'task'",
-	"id?": "string",
-	"description?": "string",
-	"role?": ROLE_INPUT_SCHEMA,
-	assignment: "string",
+	task: "string",
 	"isolated?": "boolean",
 	"+": "delete",
 });
 const taskSchemaNoIsolation = type({
+	"name?": "string",
 	agent: "string = 'task'",
-	"id?": "string",
-	"description?": "string",
-	"role?": ROLE_INPUT_SCHEMA,
-	assignment: "string",
+	task: "string",
 	"+": "delete",
 });
 const taskSchemaBatch = type({
-	agent: "string = 'task'",
 	context: "string",
 	tasks: taskItemSchemaIsolated.array(),
 	"+": "delete",
 });
 const taskSchemaBatchNoIsolation = type({
-	agent: "string = 'task'",
 	context: "string",
 	tasks: taskItemSchema.array(),
 	"+": "delete",
@@ -165,37 +152,44 @@ function createTaskSchema(options: {
 	const agent = taskAgentSchemaRule(options.defaultAgent);
 	if (options.batchEnabled) {
 		if (options.isolationEnabled) {
-			return type.raw({
+			const item = type.raw({
+				"name?": "string",
 				agent,
+				task: "string",
+				"isolated?": "boolean",
+				"+": "delete",
+			});
+			return type.raw({
 				context: "string",
-				tasks: taskItemSchemaIsolated.array(),
+				tasks: item.array(),
 				"+": "delete",
 			});
 		}
-		return type.raw({
+		const item = type.raw({
+			"name?": "string",
 			agent,
+			task: "string",
+			"+": "delete",
+		});
+		return type.raw({
 			context: "string",
-			tasks: taskItemSchema.array(),
+			tasks: item.array(),
 			"+": "delete",
 		});
 	}
 	if (options.isolationEnabled) {
 		return type.raw({
+			"name?": "string",
 			agent,
-			"id?": "string",
-			"description?": "string",
-			"role?": ROLE_INPUT_SCHEMA,
-			assignment: "string",
+			task: "string",
 			"isolated?": "boolean",
 			"+": "delete",
 		});
 	}
 	return type.raw({
+		"name?": "string",
 		agent,
-		"id?": "string",
-		"description?": "string",
-		"role?": ROLE_INPUT_SCHEMA,
-		assignment: "string",
+		task: "string",
 		"+": "delete",
 	});
 }
@@ -226,21 +220,17 @@ export function getTaskSchema(options: {
 
 /**
  * Runtime params union over both wire shapes. The model sees exactly one shape
- * (`{ agent, context, tasks[] }` when `task.batch` is on, `{ agent, ...item }`
+ * (`{ context, tasks[] }` when `task.batch` is on, `{ name?, agent?, task }`
  * otherwise); runtime stays permissive so internal callers and stale
  * transcripts using the flat form keep working under either setting.
  */
 export interface TaskParams {
-	/** Agent type to spawn; omitted values resolve from the session spawn policy. */
+	/** Stable agent name (flat form). */
+	name?: string;
+	/** Agent type to spawn (flat form); omitted values resolve from the session spawn policy. */
 	agent?: string;
-	/** Stable agent id (flat form); default = generated AdjectiveNoun. */
-	id?: string;
-	/** UI label (flat form), not seen by the subagent. */
-	description?: string;
-	/** Specialist role/expertise this subagent embodies; shapes its system-prompt identity and display name. */
-	role?: string;
 	/** The work (flat form). */
-	assignment?: string;
+	task?: string;
 	/** Batch form (`task.batch`): one subagent per item. */
 	tasks?: TaskItem[];
 	/** Batch form: shared background prepended to every assignment; required by the batch schema. */
@@ -254,11 +244,11 @@ export interface TaskParams {
  * `displayName`, or a system-prompt field. Collapses every run of whitespace
  * AND control/format characters — including U+0085 NEL, ESC/ANSI, and the
  * zero-width separators that `\s` misses — to a single space, then caps length.
- * So untrusted text (a spawn `role`, a peer activity gist) can neither break the
- * line, inject prompt structure, nor smuggle terminal escapes. Caps at `max`
- * characters (clamped to >= 1; default `ROLE_LABEL_MAX`), appending an ellipsis when truncated.
+ * So untrusted text (a generated task label, a peer activity gist) can neither
+ * break the line, inject prompt structure, nor smuggle terminal escapes. Caps at
+ * `max` characters (clamped to >= 1; default `LABEL_MAX`), appending an ellipsis when truncated.
  */
-export function oneLineLabel(text: string, max = ROLE_LABEL_MAX): string {
+export function oneLineLabel(text: string, max = LABEL_MAX): string {
 	const oneLine = text.replace(/[\p{Cc}\p{Cf}\s]+/gu, " ").trim();
 	const cap = Math.max(1, max);
 	// Count/cut by code point, not UTF-16 code unit, so truncation can never
@@ -267,16 +257,6 @@ export function oneLineLabel(text: string, max = ROLE_LABEL_MAX): string {
 	return chars.length > cap ? `${chars.slice(0, cap - 1).join("")}…` : oneLine;
 }
 
-/**
- * Display name for a spawned subagent: its tailored `role` (label-normalized)
- * when one is given, else the agent type's name. Empty/whitespace roles fall
- * back to the agent name.
- */
-export function resolveSubagentDisplayName(role: string | undefined, agentName: string): string {
-	const trimmed = role?.trim();
-	return trimmed ? oneLineLabel(trimmed) : agentName;
-}
-
 /**
  * Whether an agent at `taskDepth` may still spawn children — i.e. it currently
  * holds the `task` tool. Mirrors the task-tool availability gate;
@@ -318,7 +298,7 @@ export interface AgentDefinition {
 	tools?: string[];
 	spawns?: string[] | "*";
 	model?: string[];
-	thinkingLevel?: ThinkingLevel;
+	thinkingLevel?: ConfiguredThinkingLevel;
 	output?: unknown;
 	blocking?: boolean;
 	autoloadSkills?: string[];