@oh-my-pi/pi-coding-agent 16.2.2 → 16.2.4

package/src/task/executor.ts

@@ -71,7 +71,11 @@ import {
 	TASK_SUBAGENT_LIFECYCLE_CHANNEL,
 	TASK_SUBAGENT_PROGRESS_CHANNEL,
 	type TaskToolDetails,
+	type YieldItem,
 } from "./types";
+import { arrayValuedLabels, assembleYieldResult } from "./yield-assembly";
+
+export type { YieldItem } from "./types";
 
 const MCP_CALL_TIMEOUT_MS = 60_000;
 
@@ -517,21 +521,6 @@ function resolveFallbackCompletion(rawOutput: string, outputSchema: unknown): {
 	return { data: candidate };
 }
 
-export interface YieldItem {
-	data?: unknown;
-	status?: "success" | "aborted";
-	error?: string;
-	/**
-	 * Set by the in-tool yield validator when it exhausted its retry budget
-	 * (MAX_SCHEMA_RETRIES) and accepted a schema-invalid payload anyway.
-	 * `finalizeSubprocessOutput` honors this by serializing the payload and
-	 * surfacing a stderr warning, instead of re-emitting `schema_violation`
-	 * — which would silently swap the subagent's "accepted" view for a
-	 * different, opaque error blob in the parent's view of the result.
-	 */
-	schemaOverridden?: boolean;
-}
-
 interface FinalizeSubprocessOutputArgs {
 	rawOutput: string;
 	exitCode: number;
@@ -541,6 +530,7 @@ interface FinalizeSubprocessOutputArgs {
 	yieldItems?: YieldItem[];
 	reportFindings?: ReviewFinding[];
 	outputSchema: unknown;
+	lastAssistantText?: string;
 }
 
 interface FinalizeSubprocessOutputResult {
@@ -583,7 +573,7 @@ function buildSchemaViolationOutcome(
 
 export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult {
 	let { rawOutput, exitCode, stderr } = args;
-	const { yieldItems, reportFindings, doneAborted, signalAborted, outputSchema } = args;
+	const { yieldItems, reportFindings, doneAborted, signalAborted, outputSchema, lastAssistantText } = args;
 	let abortedViaYield = false;
 	const hasYield = Array.isArray(yieldItems) && yieldItems.length > 0;
 	const hadFailureBeforeYield = exitCode !== 0 && stderr.trim().length > 0;
@@ -600,15 +590,16 @@ export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): Fi
 				rawOutput = `{"aborted":true,"error":"${lastYield.error || "Unknown error"}"}`;
 			}
 		} else {
-			const submitData = lastYield?.data;
-			if (submitData === null || submitData === undefined) {
+			const assembled = assembleYieldResult(yieldItems, lastAssistantText, arrayValuedLabels(outputSchema));
+			if (!assembled || assembled.missingData) {
 				rawOutput = rawOutput ? `${SUBAGENT_WARNING_NULL_YIELD}\n\n${rawOutput}` : SUBAGENT_WARNING_NULL_YIELD;
 			} else {
 				const { validator, error: schemaError } = buildOutputValidator(outputSchema);
-				const overridden = lastYield?.schemaOverridden === true;
-				const completeData = normalizeCompleteData(submitData, reportFindings, validator);
+				const completeData = assembled.rawText
+					? assembled.data
+					: normalizeCompleteData(assembled.data, reportFindings, validator);
 				const result =
-					schemaError || overridden
+					schemaError || assembled.schemaOverridden
 						? { success: true as const }
 						: (validator?.validate(completeData) ?? { success: true as const });
 				if (!result.success) {
@@ -619,14 +610,17 @@ export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): Fi
 					exitCode = outcome.exitCode;
 				} else {
 					try {
-						rawOutput = JSON.stringify(completeData, null, 2) ?? "null";
+						rawOutput =
+							assembled.rawText && typeof completeData === "string"
+								? completeData
+								: (JSON.stringify(completeData, null, 2) ?? "null");
 					} catch (err) {
 						const errorMessage = err instanceof Error ? err.message : String(err);
 						rawOutput = `{"error":"Failed to serialize yield data: ${errorMessage}"}`;
 					}
 					if (!hadFailureBeforeYield) {
 						exitCode = 0;
-						stderr = overridden
+						stderr = assembled.schemaOverridden
 							? SUBAGENT_WARNING_SCHEMA_OVERRIDDEN
 							: schemaError
 								? `invalid output schema: ${schemaError}`
@@ -925,6 +919,7 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 		cacheRead: 0,
 		cacheWrite: 0,
 		totalTokens: 0,
+		reasoningTokens: 0,
 		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 	};
 	let hasUsage = false;
@@ -1315,6 +1310,8 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 						accumulatedUsage.cacheRead += getNumberField(usageRecord, "cacheRead") ?? 0;
 						accumulatedUsage.cacheWrite += getNumberField(usageRecord, "cacheWrite") ?? 0;
 						accumulatedUsage.totalTokens += getNumberField(usageRecord, "totalTokens") ?? 0;
+						accumulatedUsage.reasoningTokens =
+							(accumulatedUsage.reasoningTokens ?? 0) + (getNumberField(usageRecord, "reasoningTokens") ?? 0);
 						if (costRecord) {
 							accumulatedUsage.cost.input += getNumberField(costRecord, "input") ?? 0;
 							accumulatedUsage.cost.output += getNumberField(costRecord, "output") ?? 0;
@@ -1665,6 +1662,7 @@ async function finalizeRunResult(args: FinalizeRunArgs): Promise<SingleResult> {
 			yieldItems,
 			reportFindings,
 			outputSchema: args.outputSchema,
+			lastAssistantText: monitor.lastAssistantSalvageText(),
 		});
 	} finally {
 		popLoopPhase();

package/src/task/render.ts

@@ -34,7 +34,8 @@ import {
 import { framedBlock, renderStatusLine } from "../tui";
 import { repairDoubleEncodedJsonString } from "./repair-args";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
-import type { AgentProgress, SingleResult, TaskItem, TaskParams, TaskToolDetails } from "./types";
+import type { AgentProgress, SingleResult, TaskItem, TaskParams, TaskToolDetails, YieldItem } from "./types";
+import { assembleYieldResult } from "./yield-assembly";
 
 /** Render context threaded in from `ToolExecutionComponent.#buildRenderContext`. */
 interface TaskRenderContext {
@@ -143,6 +144,49 @@ function normalizeReportFindings(value: unknown): ReportFindingDetails[] {
 	return findings;
 }
 
+/** Reviewer output declares `findings` as an array, so a lone finding section still assembles as a list. */
+const REVIEWER_ARRAY_LABELS: ReadonlySet<string> = new Set(["findings"]);
+
+function extractIncrementalReviewResult(
+	value: unknown,
+): { summary: SubmitReviewDetails; findings: ReportFindingDetails[] } | undefined {
+	const yieldItems: YieldItem[] = normalizeYieldData(value).map(item => ({
+		data: item.data,
+		type: item.type,
+		status: item.status === "aborted" ? "aborted" : item.status === "success" ? "success" : undefined,
+		useLastTurn: item.useLastTurn,
+	}));
+	const assembled = assembleYieldResult(yieldItems, undefined, REVIEWER_ARRAY_LABELS);
+	const data = assembled?.data;
+	if (!data || typeof data !== "object" || Array.isArray(data)) return undefined;
+	const record = data as Record<string, unknown>;
+	const overallCorrectness = record.overall_correctness;
+	const explanation = record.explanation;
+	const confidence = record.confidence;
+	if (
+		(overallCorrectness !== "correct" && overallCorrectness !== "incorrect") ||
+		typeof explanation !== "string" ||
+		typeof confidence !== "number"
+	) {
+		return undefined;
+	}
+	return {
+		summary: {
+			overall_correctness: overallCorrectness,
+			explanation,
+			confidence,
+		},
+		findings: normalizeReportFindings(record.findings),
+	};
+}
+
+interface RenderYieldItem {
+	data?: unknown;
+	type?: string | string[];
+	status?: string;
+	useLastTurn?: boolean;
+}
+
 /**
  * Normalize the `yield` slot of `extractedToolData` into an array of
  * yield-detail records. The subprocess executor always populates this slot as
@@ -153,14 +197,82 @@ function normalizeReportFindings(value: unknown): ReportFindingDetails[] {
  * A single object is wrapped as a 1-element array so the review verdict still
  * renders; non-object primitives drop out.
  */
-function normalizeYieldData(value: unknown): Array<{ data: unknown }> {
-	if (Array.isArray(value)) {
-		return value.filter((item): item is { data: unknown } => item !== null && typeof item === "object");
+function normalizeYieldData(value: unknown): RenderYieldItem[] {
+	const items = Array.isArray(value) ? value : value !== null && typeof value === "object" ? [value] : [];
+	const normalized: RenderYieldItem[] = [];
+	for (const item of items) {
+		if (item === null || typeof item !== "object") continue;
+		const record = item as Record<string, unknown>;
+		const typeValue = record.type;
+		let type: RenderYieldItem["type"];
+		if (typeof typeValue === "string") {
+			type = typeValue;
+		} else if (Array.isArray(typeValue)) {
+			const labels: string[] = [];
+			let allLabels = true;
+			for (const label of typeValue) {
+				if (typeof label !== "string") {
+					allLabels = false;
+					break;
+				}
+				labels.push(label);
+			}
+			if (allLabels) type = labels;
+		}
+		normalized.push({
+			data: record.data,
+			type,
+			status: typeof record.status === "string" ? record.status : undefined,
+			useLastTurn: record.useLastTurn === true ? true : undefined,
+		});
+	}
+	return normalized;
+}
+
+function getRenderYieldLabels(type: RenderYieldItem["type"]): string[] {
+	if (typeof type === "string") {
+		const label = type.trim();
+		return label ? [label] : [];
+	}
+	if (!Array.isArray(type)) return [];
+	const labels: string[] = [];
+	for (const value of type) {
+		const label = value.trim();
+		if (label) labels.push(label);
+	}
+	return labels;
+}
+
+function formatYieldPreview(item: RenderYieldItem): string {
+	if (item.useLastTurn === true && item.data === undefined) return "last assistant turn";
+	if (item.data === undefined) return "last assistant turn";
+	if (typeof item.data === "string") return previewLine(replaceTabs(item.data), 70);
+	try {
+		return previewLine(replaceTabs(JSON.stringify(item.data) ?? "null"), 70);
+	} catch {
+		return previewLine(replaceTabs(String(item.data)), 70);
+	}
+}
+
+function renderTypedYieldSections(value: unknown, continuePrefix: string, expanded: boolean, theme: Theme): string[] {
+	const typedItems: Array<{ item: RenderYieldItem; labels: string[] }> = [];
+	for (const item of normalizeYieldData(value)) {
+		const labels = getRenderYieldLabels(item.type);
+		if (labels.length === 0) continue;
+		typedItems.push({ item, labels });
 	}
-	if (value !== null && typeof value === "object") {
-		return [value as { data: unknown }];
+	const displayCount = expanded ? typedItems.length : 3;
+	const lines: string[] = [];
+	for (const { item, labels } of typedItems.slice(-displayCount)) {
+		const terminal = !Array.isArray(item.type);
+		const prefix = terminal ? "yield" : "yield+";
+		const label = `${prefix}[${labels.join(", ")}]`;
+		lines.push(`${continuePrefix}${theme.fg("dim", label)}: ${theme.fg("dim", formatYieldPreview(item))}`);
+	}
+	if (typedItems.length > displayCount) {
+		lines.push(`${continuePrefix}${theme.fg("dim", formatMoreItems(typedItems.length - displayCount, "yield"))}`);
 	}
-	return [];
+	return lines;
 }
 
 function formatJsonScalar(value: unknown, _theme: Theme): string {
@@ -808,10 +920,24 @@ function renderAgentProgress(
 
 	// Render extracted tool data inline (e.g., review findings)
 	if (progress.extractedToolData) {
-		// For completed tasks, check for review verdict from yield tool
+		// For completed tasks, prefer review verdicts assembled from incremental
+		// yield sections. Fall back to the legacy `report_finding` side-channel.
 		if (progress.status === "completed") {
 			const completeData = normalizeYieldData(progress.extractedToolData.yield);
+			const incrementalReview = extractIncrementalReviewResult(progress.extractedToolData.yield);
 			const reportFindingData = normalizeReportFindings(progress.extractedToolData.report_finding);
+			if (incrementalReview) {
+				lines.push(
+					...renderReviewResult(
+						incrementalReview.summary,
+						incrementalReview.findings,
+						continuePrefix,
+						expanded,
+						theme,
+					),
+				);
+				return lines; // Review result handles its own rendering
+			}
 			const reviewData = completeData
 				.map(c => c.data as SubmitReviewDetails)
 				.filter(d => d && typeof d === "object" && "overall_correctness" in d);
@@ -825,6 +951,11 @@ function renderAgentProgress(
 
 		for (const toolName in progress.extractedToolData) {
 			const dataArray = progress.extractedToolData[toolName];
+			if (toolName === "yield") {
+				lines.push(...renderTypedYieldSections(dataArray, continuePrefix, expanded, theme));
+				continue;
+			}
+
 			// Handle report_finding with tree formatting
 			if (toolName === "report_finding") {
 				const findings = normalizeReportFindings(dataArray);
@@ -1068,23 +1199,30 @@ function renderAgentResult(
 			`${continuePrefix}${theme.fg("error", theme.status.aborted)} ${theme.fg("dim", previewLine(result.abortReason, 80))}`,
 		);
 	}
-	// Check for review result (yield with review schema + report_finding)
-	// Check for review result (yield with review schema + report_finding).
+	// Check for review result, preferring incremental yield sections and falling
+	// back to the legacy `report_finding` side-channel.
 	// `normalizeYieldData` guards against a stray non-array `yield` slot —
 	// optional chaining on `.map` only short-circuits on null/undefined and
 	// would otherwise crash the renderer with `TypeError: completeData?.map
 	// is not a function` when the slot is a plain object (see issue #1987).
 	const completeData = normalizeYieldData(result.extractedToolData?.yield);
 	const reportFindingData = normalizeReportFindings(result.extractedToolData?.report_finding);
+	const incrementalReview = extractIncrementalReviewResult(result.extractedToolData?.yield);
+
+	if (incrementalReview) {
+		lines.push(
+			...renderReviewResult(incrementalReview.summary, incrementalReview.findings, continuePrefix, expanded, theme),
+		);
+		return lines;
+	}
 
-	// Extract review verdict from yield tool's data field if it matches SubmitReviewDetails
+	// Extract review verdict from legacy yield summary objects if present.
 	const reviewData = completeData
 		.map(c => c.data as SubmitReviewDetails)
 		.filter(d => d && typeof d === "object" && "overall_correctness" in d);
 	const submitReviewData = reviewData.length > 0 ? reviewData : undefined;
 
 	if (submitReviewData) {
-		// Use combined review renderer
 		const summary = submitReviewData[submitReviewData.length - 1];
 		const findings = reportFindingData;
 		lines.push(...renderReviewResult(summary, findings, continuePrefix, expanded, theme));
@@ -1105,9 +1243,18 @@ function renderAgentResult(
 	let hasCustomRendering = false;
 	const deferredToolLines: string[] = [];
 	if (result.extractedToolData) {
-		for (const [toolName, dataArray] of Object.entries(result.extractedToolData)) {
+		for (const toolName in result.extractedToolData) {
+			const dataArray = result.extractedToolData[toolName];
+			if (toolName === "yield") {
+				const yieldLines = renderTypedYieldSections(dataArray, continuePrefix, expanded, theme);
+				if (yieldLines.length > 0) {
+					hasCustomRendering = true;
+					lines.push(...yieldLines);
+				}
+				continue;
+			}
 			// Skip review tools - handled above
-			if (toolName === "yield" || toolName === "report_finding") continue;
+			if (toolName === "report_finding") continue;
 
 			const isTaskTool = toolName === "task";
 			if (isTaskTool && (dataArray as unknown[]).length > 0) {
@@ -1541,6 +1688,7 @@ function renderNestedTaskTree(
 	return lines;
 }
 
+// Register task tool subprocess handler
 subprocessToolRegistry.register<TaskToolDetails>("task", {
 	extractData: event => {
 		const details = event.result?.details;
@@ -1551,9 +1699,3 @@ subprocessToolRegistry.register<TaskToolDetails>("task", {
 		return new Text(lines.join("\n"), 0, 0);
 	},
 });
-
-export const taskToolRenderer = {
-	renderCall,
-	renderResult,
-	mergeCallAndResult: true,
-};

package/src/task/renderer.ts

@@ -0,0 +1,14 @@
+/**
+ * Task tool renderer export.
+ *
+ * Separated from render.ts to avoid circular dependency issues with
+ * tools/renderers.ts. This module has no side effects and can be safely
+ * imported without triggering the subprocessToolRegistry registration.
+ */
+import { renderCall, renderResult } from "./render";
+
+export const taskToolRenderer = {
+	renderCall,
+	renderResult,
+	mergeCallAndResult: true,
+} as const;

package/src/task/types.ts

@@ -257,6 +257,23 @@ export interface AgentDefinition {
 	filePath?: string;
 }
 
+/** Details extracted from a subagent `yield` tool call for final-result assembly and task rendering. */
+export interface YieldItem {
+	data?: unknown;
+	status?: "success" | "aborted";
+	error?: string;
+	/** A string label is terminal; a non-empty array of labels is incremental. */
+	type?: string | string[];
+	/** Resolve this yield's payload from the latest durable assistant text instead of `data`. */
+	useLastTurn?: boolean;
+	/**
+	 * Set by the in-tool yield validator when it exhausted its retry budget and
+	 * accepted schema-invalid data anyway. The executor preserves that override
+	 * during post-mortem validation.
+	 */
+	schemaOverridden?: boolean;
+}
+
 /** Progress tracking for a single agent */
 export interface AgentProgress {
 	index: number;

package/src/task/yield-assembly.ts

@@ -0,0 +1,207 @@
+/**
+ * Pure assembly of subagent `yield` calls into the final payload consumed by
+ * output-schema validation.
+ *
+ * Lives apart from the subagent runtime in `executor.ts` so the rendering path
+ * (`render.ts` → `extractIncrementalReviewResult`) can assemble incremental
+ * yields without importing that runtime's dependency graph (`sdk`,
+ * `session-manager`, the TUI tool renderers). It has no side effects and
+ * depends only on the yield type and the output-schema validator.
+ */
+import { buildOutputValidator } from "../tools/output-schema-validator";
+import type { YieldItem } from "./types";
+
+/** Outcome of folding a run's yield calls into one payload, with provenance flags. */
+interface AssembledYieldResult {
+	data: unknown;
+	schemaOverridden: boolean;
+	rawText: boolean;
+	missingData: boolean;
+}
+
+function isIncrementalYieldType(type: YieldItem["type"]): type is string[] {
+	return Array.isArray(type) && type.length > 0;
+}
+
+function getYieldLabels(type: YieldItem["type"]): string[] {
+	if (typeof type === "string") {
+		const label = type.trim();
+		return label ? [label] : [];
+	}
+	if (!Array.isArray(type)) return [];
+	const labels: string[] = [];
+	for (const value of type) {
+		if (typeof value !== "string") continue;
+		const label = value.trim();
+		if (label) labels.push(label);
+	}
+	return labels;
+}
+
+function resolveYieldPayload(
+	item: YieldItem,
+	lastAssistantText: string | undefined,
+	labels: string[],
+): { value: unknown; fromLastAssistantText: boolean; missingData: boolean } {
+	const hasData = item.data !== undefined;
+	const shouldUseLastTurn = item.useLastTurn === true || (labels.length > 0 && !hasData);
+	if (shouldUseLastTurn && lastAssistantText !== undefined) {
+		return {
+			value: lastAssistantText,
+			fromLastAssistantText: true,
+			missingData: lastAssistantText.length === 0,
+		};
+	}
+	return {
+		value: item.data,
+		fromLastAssistantText: false,
+		missingData: item.data === undefined || item.data === null,
+	};
+}
+
+function appendYieldSection(
+	sections: Record<string, unknown>,
+	sectionCounts: Map<string, number>,
+	label: string,
+	value: unknown,
+	forceArray: boolean,
+): void {
+	const count = sectionCounts.get(label) ?? 0;
+	const existing = sections[label];
+	if (count === 0) {
+		sections[label] = forceArray ? [value] : value;
+	} else if (Array.isArray(existing)) {
+		existing.push(value);
+	} else {
+		sections[label] = [existing, value];
+	}
+	sectionCounts.set(label, count + 1);
+}
+
+/** True when `value` is a JSON-schema node whose instances are arrays. */
+function isArrayTypedSchema(value: unknown): boolean {
+	if (value === null || typeof value !== "object") return false;
+	const record = value as Record<string, unknown>;
+	if (record.type === "array") return true;
+	if (Array.isArray(record.type) && record.type.includes("array")) return true;
+	for (const key of ["anyOf", "oneOf", "allOf"] as const) {
+		const variants = record[key];
+		if (Array.isArray(variants) && variants.some(isArrayTypedSchema)) return true;
+	}
+	return false;
+}
+
+/**
+ * Top-level output-schema property names declared as arrays (JTD `elements` →
+ * JSON `type: "array"`). An incremental yield section for such a label
+ * accumulates into a list even when the agent emits exactly one — otherwise a
+ * single `type: ["findings"]` yield would assemble as a bare object and fail
+ * array-typed schema validation.
+ */
+export function arrayValuedLabels(outputSchema: unknown): ReadonlySet<string> {
+	const labels = new Set<string>();
+	// Use the JTD-converted JSON Schema (matches what validation runs against):
+	// JTD `optionalProperties.findings.elements` becomes `properties.findings`
+	// with `type: "array"`, which raw `normalizeSchema` would not expose.
+	const { jsonSchema } = buildOutputValidator(outputSchema);
+	if (jsonSchema === undefined) return labels;
+	const properties = jsonSchema.properties;
+	if (properties === null || typeof properties !== "object") return labels;
+	const propRecord = properties as Record<string, unknown>;
+	for (const key in propRecord) {
+		if (isArrayTypedSchema(propRecord[key])) labels.add(key);
+	}
+	return labels;
+}
+
+/**
+ * Assemble typed yield calls into the final payload consumed by schema validation.
+ *
+ * A non-empty array `type` contributes an incremental section and never decides
+ * termination by itself. A string `type` with omitted `data` makes the last
+ * assistant turn the raw terminal result. Other string-typed yields contribute
+ * the terminal labelled section. Untyped terminal yields keep the historical
+ * "last yield wins" behavior unless no terminal yield exists, in which case
+ * accumulated typed sections finalize on idle.
+ */
+export function assembleYieldResult(
+	yieldItems: YieldItem[],
+	lastAssistantText?: string,
+	arrayLabels?: ReadonlySet<string>,
+): AssembledYieldResult | undefined {
+	if (yieldItems.length === 0) return undefined;
+	let terminalItem: YieldItem | undefined;
+	for (let index = yieldItems.length - 1; index >= 0; index--) {
+		const item = yieldItems[index];
+		if (!item) continue;
+		if (!isIncrementalYieldType(item.type)) {
+			terminalItem = item;
+			break;
+		}
+	}
+	let hasTypedSections = false;
+	for (const item of yieldItems) {
+		if (getYieldLabels(item.type).length > 0) {
+			hasTypedSections = true;
+			break;
+		}
+	}
+	if (terminalItem && typeof terminalItem.type === "string" && terminalItem.data === undefined) {
+		const resolved = resolveYieldPayload(terminalItem, lastAssistantText, getYieldLabels(terminalItem.type));
+		return {
+			data: resolved.value,
+			schemaOverridden: terminalItem.schemaOverridden === true,
+			rawText: resolved.fromLastAssistantText && typeof resolved.value === "string",
+			missingData: resolved.missingData,
+		};
+	}
+	if (!hasTypedSections && terminalItem) {
+		const resolved = resolveYieldPayload(terminalItem, lastAssistantText, []);
+		return {
+			data: resolved.value,
+			schemaOverridden: terminalItem.schemaOverridden === true,
+			rawText: resolved.fromLastAssistantText && typeof resolved.value === "string",
+			missingData: resolved.missingData,
+		};
+	}
+
+	const sections: Record<string, unknown> = {};
+	const sectionCounts = new Map<string, number>();
+	let schemaOverridden = false;
+	let missingData = false;
+	let hasSections = false;
+
+	for (const item of yieldItems) {
+		if (item.status === "aborted") continue;
+		schemaOverridden ||= item.schemaOverridden === true;
+		const labels = getYieldLabels(item.type);
+		if (labels.length === 0) continue;
+		const resolved = resolveYieldPayload(item, lastAssistantText, labels);
+		missingData ||= resolved.missingData;
+		const incremental = isIncrementalYieldType(item.type);
+		for (const label of labels) {
+			appendYieldSection(
+				sections,
+				sectionCounts,
+				label,
+				resolved.value,
+				incremental && (arrayLabels?.has(label) ?? false),
+			);
+			hasSections = true;
+		}
+		if (!isIncrementalYieldType(item.type)) break;
+	}
+
+	if (hasSections) {
+		return { data: sections, schemaOverridden, rawText: false, missingData };
+	}
+
+	if (!terminalItem) return undefined;
+	const resolved = resolveYieldPayload(terminalItem, lastAssistantText, []);
+	return {
+		data: resolved.value,
+		schemaOverridden: terminalItem.schemaOverridden === true,
+		rawText: resolved.fromLastAssistantText && typeof resolved.value === "string",
+		missingData: resolved.missingData,
+	};
+}

package/src/tiny/text.ts

@@ -43,6 +43,29 @@ export function formatTitleUserMessage(message: string): string {
 	return `<user-message>\n${prepareTitleInput(message)}\n</user-message>`;
 }
 
+/** Single recent conversation turn supplied to title refresh after replanning. */
+export interface TitleConversationTurn {
+	role: "user" | "assistant";
+	text?: string;
+	thinking?: string;
+}
+
+/** Format recent user/assistant context for title generation after a todo replan. */
+export function formatTitleConversationContext(turns: readonly TitleConversationTurn[]): string {
+	const formattedTurns: string[] = [];
+	for (const turn of turns) {
+		const sections: string[] = [];
+		const text = turn.text?.trim();
+		if (text) sections.push(text);
+		const thinking = turn.role === "assistant" ? turn.thinking?.trim() : undefined;
+		if (thinking) sections.push(`<thinking>\n${thinking}\n</thinking>`);
+		if (sections.length === 0) continue;
+		formattedTurns.push(`<${turn.role}>\n${sections.join("\n\n")}\n</${turn.role}>`);
+	}
+	if (formattedTurns.length === 0) return "";
+	return prepareTitleInput(`<conversation>\n${formattedTurns.join("\n\n")}\n</conversation>`);
+}
+
 /**
  * Greeting / acknowledgement / filler tokens. A first user message composed
  * entirely of these (or of bare numbers / punctuation / emoji) carries no