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

package/src/tools/review.ts

@@ -1,9 +1,10 @@
 /**
- * Review tools - report_finding for structured code review.
+ * Legacy hidden review-finding tool for agents that have not migrated to
+ * incremental `yield` sections.
  *
- * Used by the reviewer agent to report findings in a structured way.
- * Hidden by default - only enabled when explicitly listed in agent's tools.
- * Reviewers finish via `yield` tool with SubmitReviewDetails schema.
+ * Hidden by default - only enabled when explicitly listed in an agent's tools.
+ * Reviewers now finish via incremental `yield`; this tool remains for
+ * compatibility with older or custom review agents.
  */
 // ─────────────────────────────────────────────────────────────────────────────
 
@@ -33,6 +34,10 @@ const PRIORITY_INFO: Record<FindingPriority, FindingPriorityInfo> = {
 
 export const PRIORITY_LABELS: FindingPriority[] = ["P0", "P1", "P2", "P3"];
 
+export function isFindingPriority(value: unknown): value is FindingPriority {
+	return value === "P0" || value === "P1" || value === "P2" || value === "P3";
+}
+
 export function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo {
 	return PRIORITY_INFO[priority] ?? { ord: 3, symbol: "status.info", color: "muted" };
 }
@@ -72,8 +77,13 @@ interface ReportFindingDetails {
 	line_end: number;
 }
 
-function isFindingPriority(value: unknown): value is FindingPriority {
-	return value === "P0" || value === "P1" || value === "P2" || value === "P3";
+function normalizeFindingPriority(value: unknown): FindingPriority | undefined {
+	if (isFindingPriority(value)) return value;
+	if (value === 0) return "P0";
+	if (value === 1) return "P1";
+	if (value === 2) return "P2";
+	if (value === 3) return "P3";
+	return undefined;
 }
 
 export function parseReportFindingDetails(value: unknown): ReportFindingDetails | undefined {
@@ -81,7 +91,7 @@ export function parseReportFindingDetails(value: unknown): ReportFindingDetails
 
 	const title = typeof value.title === "string" ? value.title : undefined;
 	const body = typeof value.body === "string" ? value.body : undefined;
-	const priority = isFindingPriority(value.priority) ? value.priority : undefined;
+	const priority = normalizeFindingPriority(value.priority);
 	const confidence =
 		typeof value.confidence === "number" &&
 		Number.isFinite(value.confidence) &&

package/src/tools/ssh.ts

@@ -369,10 +369,14 @@ export const sshToolRenderer = {
 		});
 	},
 	mergeCallAndResult: true,
-	// Collapsed pending preview caps the command to a viewport-sized tail window
-	// that shifts while args stream. Expanded output is top-anchored enough for
-	// the transcript to commit its settled prefix.
-	provisionalPendingPreview: "collapsed",
+	// Pending call preview can re-anchor wholesale when the final result inserts
+	// the `Output` section, so no pending SSH rows may commit to native
+	// scrollback — even when expanded. The expanded pending shape was previously
+	// allowed to commit, which left two visible shapes in native scrollback once
+	// the result settled: a stale `⏳ SSH: [host]` header above the final frame,
+	// and the pending `╰──╯` footer reused in-place as the new `├── Output ──┤`
+	// separator with a fresh footer pushed below it.
+	provisionalPendingPreview: true,
 	// Partial-result chrome (pending icon and frame state) differs from the
 	// final SSH glyph/state, so the block stays commit-unstable while
 	// `options.isPartial` holds. Without this, a long-running SSH command's

package/src/tools/todo.ts

@@ -19,6 +19,8 @@ import { formatErrorDetail, PREVIEW_LIMITS } from "./render-utils";
 // =============================================================================
 
 export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
+/** Operation names accepted by the todo tool and echoed in successful result details. */
+export type TodoOperation = "init" | "start" | "done" | "rm" | "drop" | "append" | "view";
 
 export interface TodoItem {
 	content: string;
@@ -36,6 +38,8 @@ export interface TodoCompletionTransition {
 }
 
 export interface TodoToolDetails {
+	/** Operation that produced this snapshot; absent on legacy transcript entries. */
+	op?: TodoOperation;
 	phases: TodoPhase[];
 	storage: "session" | "memory";
 	completedTasks?: TodoCompletionTransition[];
@@ -134,6 +138,18 @@ function normalizeInProgressTask(phases: TodoPhase[]): void {
 	if (firstPendingTask) firstPendingTask.status = "in_progress";
 }
 
+/** Return the active todo task, preferring an in-progress item over the first pending item. */
+export function nextActionableTask(phases: readonly TodoPhase[]): TodoItem | undefined {
+	let firstPending: TodoItem | undefined;
+	for (const phase of phases) {
+		for (const task of phase.tasks) {
+			if (task.status === "in_progress") return task;
+			if (!firstPending && task.status === "pending") firstPending = task;
+		}
+	}
+	return firstPending;
+}
+
 export const USER_TODO_EDIT_CUSTOM_TYPE = "user_todo_edit";
 
 export function getLatestTodoPhasesFromEntries(entries: SessionEntry[]): TodoPhase[] {
@@ -626,7 +642,7 @@ export class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
 		const completedTasks = readOnly || failed ? [] : getCompletionTransitions(previousPhases, updated);
 		if (!readOnly && !failed) this.session.setTodoPhases?.(updated);
 		const storage = this.session.getSessionFile() ? "session" : "memory";
-		const details: TodoToolDetails = { phases: effective, storage };
+		const details: TodoToolDetails = { op: params.op, phases: effective, storage };
 		if (completedTasks.length > 0) details.completedTasks = completedTasks;
 
 		return {

package/src/tools/yield.ts

@@ -1,7 +1,7 @@
 /**
- * Submit result tool for structured subagent output.
+ * Result submission tool for subagent output.
  *
- * Subagents must call this tool to finish and return structured JSON output.
+ * Subagents can call this tool incrementally or terminally depending on `type`.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { TSchema } from "@oh-my-pi/pi-ai/types";
@@ -17,9 +17,14 @@ import type { ToolSession } from ".";
 import { buildOutputValidator, formatAllValidationIssues } from "./output-schema-validator";
 
 export interface YieldDetails {
-	data: unknown;
+	/** Successful result payload, or omitted when `useLastTurn` requests last-turn extraction. */
+	data?: unknown;
 	status: "success" | "aborted";
 	error?: string;
+	/** Optional result section/classification supplied by the yield caller. */
+	type?: string | string[];
+	/** True when the caller intentionally omitted success data so the executor uses the last assistant turn. */
+	useLastTurn?: boolean;
 	/**
 	 * Set when the yield tool exhausted its in-tool schema-retry budget
 	 * (MAX_SCHEMA_RETRIES) and accepted the data anyway. Surfaced so the
@@ -66,30 +71,108 @@ function hasUnresolvedRefs(schema: unknown): boolean {
 	return false;
 }
 
+const yieldTypeSchema: Record<string, unknown> = {
+	anyOf: [
+		{ type: "string" },
+		{
+			type: "array",
+			minItems: 1,
+			items: { type: "string" },
+		},
+	],
+	description: "Optional result type. A non-empty string array is incremental; a string is terminal.",
+};
+
+function isYieldType(value: unknown): value is string | string[] {
+	return (
+		typeof value === "string" ||
+		(Array.isArray(value) && value.length > 0 && value.every(item => typeof item === "string"))
+	);
+}
+
+function parseYieldType(value: unknown): string | string[] | undefined {
+	// Strict-mode providers (OpenAI/Codex) make the optional `type` property
+	// required+nullable, so an untyped final yield arrives as `type: null`.
+	if (value === undefined || value === null) return undefined;
+	if (isYieldType(value)) return value;
+	throw new Error("type must be a string or non-empty array of strings");
+}
+
+/**
+ * Expand a plain-object `data` schema into a strict union that ALSO accepts each
+ * top-level section value (and array element) on its own. Agents that yield
+ * incrementally (`type: ["findings"]`, `type: ["confidence"]`, …) submit one
+ * section per call, so `data` is a single finding object or a lone verdict value
+ * — never the full output object. Without this, strict-mode providers constrain
+ * `data` to the whole schema and reject/—under constrained decoding—forbid the
+ * partial. Every branch is a typed sub-schema, so strict representability holds;
+ * the full-output object stays the first (terminal) branch. The assembled whole
+ * is still validated against the full schema at finalization. Non-object / loose
+ * schemas are returned unchanged.
+ */
+function withSectionVariants(dataSchema: Record<string, unknown>): Record<string, unknown> {
+	if (dataSchema.type !== "object") return dataSchema;
+	const props = dataSchema.properties;
+	if (props === null || typeof props !== "object") return dataSchema;
+	const propRecord = props as Record<string, unknown>;
+	const { description, ...fullWithoutDescription } = dataSchema;
+	const branches: unknown[] = [];
+	const seen = new Set<string>();
+	const add = (schema: unknown): void => {
+		if (schema === null || typeof schema !== "object") return;
+		const key = JSON.stringify(schema);
+		if (seen.has(key)) return;
+		seen.add(key);
+		branches.push(schema);
+	};
+	add(fullWithoutDescription);
+	for (const name in propRecord) {
+		const prop = propRecord[name];
+		add(prop);
+		if (prop !== null && typeof prop === "object") {
+			const propObj = prop as Record<string, unknown>;
+			if (propObj.type === "array") add(propObj.items);
+		}
+	}
+	if (branches.length <= 1) return dataSchema;
+	return description !== undefined ? { description, anyOf: branches } : { anyOf: branches };
+}
+
 function wrapYieldParameters(dataSchema: Record<string, unknown>): Record<string, unknown> {
+	const successResultSchema = {
+		type: "object",
+		additionalProperties: false,
+		description: "task succeeded",
+		properties: { data: dataSchema },
+		required: ["data"],
+	};
+	const errorResultSchema = {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			error: { type: "string", description: "error message" },
+		},
+		required: ["error"],
+	};
+	const lastTurnResultSchema = {
+		type: "object",
+		additionalProperties: false,
+		description: "typed task succeeded; data omitted so the last assistant turn is used",
+		properties: {},
+		required: [],
+	};
+	// The "an empty `result` (last-turn) requires a `type`" invariant is enforced
+	// in `execute()` at runtime, NOT in this schema: a top-level combinator
+	// (`allOf`/`anyOf`/`oneOf`/...) makes OpenAI/Codex Responses reject the whole
+	// tool with `invalid_function_parameters`, so the wrapper stays a plain object.
 	return {
 		type: "object",
 		additionalProperties: false,
 		description: "submit data or error",
 		properties: {
+			type: yieldTypeSchema,
 			result: {
-				anyOf: [
-					{
-						type: "object",
-						additionalProperties: false,
-						description: "task succeeded",
-						properties: { data: dataSchema },
-						required: ["data"],
-					},
-					{
-						type: "object",
-						additionalProperties: false,
-						properties: {
-							error: { type: "string", description: "error message" },
-						},
-						required: ["error"],
-					},
-				],
+				anyOf: [successResultSchema, errorResultSchema, lastTurnResultSchema],
 			},
 		},
 		required: ["result"],
@@ -110,9 +193,9 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 	readonly approval = "read" as const;
 	readonly label = "Submit Result";
 	readonly description =
-		"Finish the task with structured JSON output. Call exactly once at the end of the task.\n\n" +
-		'Pass `result: { data: <your output> }` for success, or `result: { error: "message" }` for failure.\n' +
-		"The `data`/`error` wrapper is required — do not put your output directly in `result`.";
+		"Submit subagent output. Omit `type` for the usual final structured result.\n\n" +
+		'Pass `type: ["section"]` to submit an incremental, non-terminal section that accumulates. Pass `type: "result"` to finalize; when `data` is omitted, your last assistant turn becomes the raw final result.\n' +
+		'Use `result: { data: <your output> }` for success, or `result: { error: "message" }` for failure. Keep the `result` wrapper.';
 	readonly parameters: TSchema;
 	strict = true;
 	readonly intent = "omit" as const;
@@ -163,7 +246,7 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 				if (hasUnresolvedRefs(resolved)) {
 					throw new Error("schema contains unresolved $ref after dereferencing");
 				}
-				dataSchema = resolved;
+				dataSchema = withSectionVariants(resolved);
 			} else {
 				this.strict = false;
 				dataSchema = looseRecordSchema(
@@ -198,15 +281,21 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 		if (!rawResult || typeof rawResult !== "object" || Array.isArray(rawResult)) {
 			throw new Error("result must be an object containing either data or error");
 		}
-
 		const resultRecord = rawResult as Record<string, unknown>;
 		const errorMessage = typeof resultRecord.error === "string" ? resultRecord.error : undefined;
 		const data = resultRecord.data;
+		const yieldType = parseYieldType(raw.type);
+		const useLastTurn =
+			errorMessage === undefined && data === undefined && yieldType !== undefined && !("error" in resultRecord);
+		// Incremental array-typed sections carry partial data (one finding, one
+		// field) that cannot satisfy the full output schema; the assembled result
+		// is validated as a whole at finalization (executor finalizeSubprocessOutput).
+		const isIncremental = Array.isArray(yieldType) && yieldType.length > 0;
 
 		if (errorMessage !== undefined && data !== undefined) {
 			throw new Error("result cannot contain both data and error");
 		}
-		if (errorMessage === undefined && data === undefined) {
+		if (errorMessage === undefined && data === undefined && yieldType === undefined) {
 			throw new Error(
 				'result must contain either `data` or `error`. Use `{result: {data: <your output>}}` for success or `{result: {error: "message"}}` for failure.',
 			);
@@ -214,11 +303,11 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 
 		const status = errorMessage !== undefined ? "aborted" : "success";
 		let schemaValidationOverridden = false;
-		if (status === "success") {
-			if (data === undefined || data === null) {
+		if (status === "success" && !useLastTurn) {
+			if (data === null) {
 				throw new Error("data is required when yield indicates success");
 			}
-			if (this.#validate) {
+			if (this.#validate && !isIncremental) {
 				const parsed = this.#validate(data);
 				if (!parsed.success) {
 					this.#schemaValidationFailures++;
@@ -245,7 +334,14 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 					: "Result submitted.";
 		return {
 			content: [{ type: "text", text: responseText }],
-			details: { data, status, error: errorMessage, schemaOverridden: schemaValidationOverridden || undefined },
+			details: {
+				data,
+				status,
+				error: errorMessage,
+				type: yieldType,
+				useLastTurn: useLastTurn || undefined,
+				schemaOverridden: schemaValidationOverridden || undefined,
+			},
 		};
 	}
 }
@@ -262,8 +358,21 @@ subprocessToolRegistry.register<YieldDetails>("yield", {
 			data: record.data,
 			status,
 			error: typeof record.error === "string" ? record.error : undefined,
+			type: isYieldType(record.type) ? record.type : undefined,
+			useLastTurn: record.useLastTurn === true ? true : undefined,
 			schemaOverridden: record.schemaOverridden === true ? true : undefined,
 		};
 	},
-	shouldTerminate: event => !event.isError,
+	shouldTerminate: event => {
+		if (event.isError) return false;
+		const details = event.result?.details;
+		if (!details || typeof details !== "object") return true;
+		const record = details as Record<string, unknown>;
+		return !(
+			record.status === "success" &&
+			Array.isArray(record.type) &&
+			record.type.length > 0 &&
+			record.type.every(item => typeof item === "string")
+		);
+	},
 });

package/src/utils/thinking-display.ts

@@ -1,3 +1,5 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+
 export function canonicalizeMessage(text: string | null | undefined): string {
 	if (!text) return "";
 	const trimmed = text.trim();
@@ -79,6 +81,7 @@ export function formatThinkingForDisplay(text: string, proseOnly: boolean): stri
 	return formatted;
 }
 
+/** Whether a formatted thinking block has non-placeholder content worth rendering. */
 export function hasDisplayableThinking(
 	text: string | null | undefined,
 	formattedText: string | null | undefined,
@@ -87,3 +90,15 @@ export function hasDisplayableThinking(
 	if (!formattedText) return false;
 	return formattedText.length > 0 && canonicalizeMessage(text).length > 0;
 }
+
+/** Whether an assistant message contains thinking content the TUI can reveal. */
+export function messageHasDisplayableThinking(message: AgentMessage, proseOnly: boolean): boolean {
+	if (message.role !== "assistant") return false;
+	for (const content of message.content) {
+		if (content.type !== "thinking") continue;
+		if (hasDisplayableThinking(content.thinking, formatThinkingForDisplay(content.thinking, proseOnly))) {
+			return true;
+		}
+	}
+	return false;
+}