fix(message): stop showing red '! terminated' for benign stop reasons

The model finishes a response, upstream emits a non-standard finish_reason
like "terminated" / "end_turn" / "stop_sequence", pi-ai surfaces it as
errorMessage, and our renderer slapped a red "! terminated" under a
perfectly good message — making every successful response look like a
failure.

Classify the errorMessage before deciding how to render. Benign stop
signals on a message with text content collapse to nothing. Empty
responses still get a "(empty response)" warning. Length / max_tokens
become a yellow "(response truncated)" so the user knows why their
message ended mid-sentence. Anything else still renders as a real error.

Author: halfaipg

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "codebase-cli",
-	"version": "2.0.0-pre.43",
+	"version": "2.0.0-pre.44",
 	"description": "Codebase CLI — a TypeScript coding agent on the pi-mono runtime. OAuth-aware, any LLM provider, single install.",
 	"keywords": [
 		"ai",

src/ui/Message-error.test.ts

@@ -0,0 +1,74 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { describe, expect, it } from "vitest";
+
+// errorMessageNote is unexported by Message.tsx but we don't want to widen
+// Message.tsx's public surface just for tests. Instead, exercise the same
+// classifier via the testable side: import-and-call. We re-export it from
+// a sibling test-helper-friendly file when this becomes load-bearing —
+// for now, replicate the cases the rendering relies on by importing the
+// classifier directly. The function is internal but accessible via the
+// CJS interop: import all named exports through the module path.
+import { errorMessageNote } from "./Message.js";
+
+function assistant(text: string, errorMessage?: string): AgentMessage & { role: "assistant" } {
+	return {
+		role: "assistant",
+		content: text ? [{ type: "text", text }] : [],
+		api: "chat",
+		provider: "p",
+		model: "m",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: 1,
+		errorMessage,
+	} as unknown as AgentMessage & { role: "assistant" };
+}
+
+describe("errorMessageNote", () => {
+	it("returns null when there is no errorMessage", () => {
+		expect(errorMessageNote(assistant("hi"))).toBeNull();
+	});
+
+	it("hides quirky stop reasons when the message has substantive content", () => {
+		expect(errorMessageNote(assistant("a long response body", "terminated"))).toBeNull();
+		expect(errorMessageNote(assistant("content", "end_turn"))).toBeNull();
+		expect(errorMessageNote(assistant("content", "stop_sequence"))).toBeNull();
+		expect(errorMessageNote(assistant("content", "Provider finish_reason: terminated"))).toBeNull();
+	});
+
+	it("surfaces a benign-stop errorMessage as 'empty response' when the message has no text", () => {
+		const note = errorMessageNote(assistant("", "terminated"));
+		expect(note?.severity).toBe("warning");
+		expect(note?.text).toMatch(/empty response/i);
+	});
+
+	it("flags length / max_tokens as a truncation warning regardless of content", () => {
+		const note = errorMessageNote(assistant("partial body...", "length"));
+		expect(note?.severity).toBe("warning");
+		expect(note?.text).toMatch(/truncated/i);
+		const note2 = errorMessageNote(assistant("partial", "Provider finish_reason: max_tokens"));
+		expect(note2?.severity).toBe("warning");
+	});
+
+	it("renders unknown / unrecognized errorMessages as real errors", () => {
+		const note = errorMessageNote(assistant("text", "Network failure: connect ECONNREFUSED"));
+		expect(note?.severity).toBe("error");
+		expect(note?.text).toMatch(/^error:/);
+	});
+
+	it("trims surrounding whitespace before classifying", () => {
+		expect(errorMessageNote(assistant("text", "  terminated  "))).toBeNull();
+	});
+
+	it("treats whitespace-only content as empty for the no-content branch", () => {
+		const note = errorMessageNote(assistant("   ", "terminated"));
+		expect(note?.severity).toBe("warning");
+	});
+});

src/ui/Message.tsx

@@ -88,11 +88,19 @@ function MessageBody({
 
 	if (message.role === "assistant") {
 		const rendered = renderAssistantBlocks(message.content, width, tools);
+		const note = errorMessageNote(message);
 		return (
 			<>
 				{rendered}
-				{message.errorMessage ? (
-					<WrappedLines text={`! ${message.errorMessage}`} width={width} keyPrefix="err" color="red" />
+				{note ? (
+					<WrappedLines
+						text={note.text}
+						width={width}
+						keyPrefix="err"
+						color={note.severity === "error" ? "red" : undefined}
+						dimColor={note.severity === "info"}
+						italic={note.severity === "info"}
+					/>
 				) : null}
 			</>
 		);
@@ -228,6 +236,67 @@ function UserBlocks({ blocks, width }: { blocks: unknown; width: number }) {
 	return <>{rows}</>;
 }
 
+/**
+ * Stop-reason strings that are upstream-provider bookkeeping ("the model
+ * said it's done"), not real errors. Different providers use different
+ * wording for the same "I finished" signal; the pi-ai layer surfaces them
+ * uniformly as errorMessage which makes everything look red. Treat these
+ * as quiet end-of-turn markers instead.
+ */
+const QUIET_END_PATTERNS = [
+	/^terminated$/i,
+	/^end[_ ]turn$/i,
+	/^stop$/i,
+	/^stop[_ ]sequence$/i,
+	/^Provider finish_reason: (?:terminated|end_turn|stop|stop_sequence)$/i,
+];
+
+/**
+ * Stop-reason strings that mean "the response was truncated against the
+ * user's intent" — content was cut off by a length limit. The user should
+ * see this so they understand why the message ends abruptly.
+ */
+const TRUNCATION_PATTERNS = [/^length$/i, /^max[_ ]tokens$/i, /^Provider finish_reason: (?:length|max_tokens)$/i];
+
+interface ErrorMessageNote {
+	text: string;
+	severity: "info" | "warning" | "error";
+}
+
+/**
+ * Decide how to render the assistant message's errorMessage tail. A
+ * model that finished with substantive text content but a quirky
+ * non-standard stop reason shouldn't get a red "!" — that reads as a
+ * failure. Real failures (empty response, content filter, network) do
+ * get the loud treatment. Truncation gets a middle ground.
+ */
+export function errorMessageNote(message: AgentMessage & { role: "assistant" }): ErrorMessageNote | null {
+	const raw = message.errorMessage;
+	if (!raw) return null;
+	const trimmed = raw.trim();
+	const hasContent = messageHasVisibleText(message);
+
+	if (TRUNCATION_PATTERNS.some((re) => re.test(trimmed))) {
+		return { text: "(response truncated — model hit its output length limit)", severity: "warning" };
+	}
+	if (QUIET_END_PATTERNS.some((re) => re.test(trimmed))) {
+		// Benign stop signal with content — drop entirely. Without content
+		// it's an empty response, which IS noteworthy.
+		return hasContent ? null : { text: "(empty response)", severity: "warning" };
+	}
+	// Anything else: real error. Loud and explicit.
+	return { text: `error: ${trimmed}`, severity: "error" };
+}
+
+function messageHasVisibleText(message: AgentMessage): boolean {
+	if (typeof message.content === "string") return message.content.trim().length > 0;
+	if (!Array.isArray(message.content)) return false;
+	for (const block of message.content) {
+		if (block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0) return true;
+	}
+	return false;
+}
+
 function formatBytes(n: number): string {
 	if (n < 1024) return `${n} B`;
 	if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;