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

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/models.ts

@@ -87,8 +87,9 @@ void TINY_TITLE_MODEL_VALUES_MATCH_REGISTRY;
 export const TINY_TITLE_MODEL_OPTIONS = [
 	{
 		value: ONLINE_TINY_TITLE_MODEL_KEY,
-		label: "Online (pi/smol)",
-		description: "Current online title generation path; no local model download or on-device inference.",
+		label: "Online (TINY role, else pi/smol)",
+		description:
+			"Online title generation: the TINY model role (set one in /models) when assigned, otherwise the online fallback (commit role, then pi/smol). No local download or on-device inference.",
 	},
 	...TINY_TITLE_LOCAL_MODELS.map(model => ({
 		value: model.key,
@@ -183,9 +184,9 @@ void TINY_MEMORY_MODEL_VALUES_MATCH_REGISTRY;
 export const TINY_MEMORY_MODEL_OPTIONS = [
 	{
 		value: ONLINE_MEMORY_MODEL_KEY,
-		label: "Online (smol/remote)",
+		label: "Online (TINY role, else smol)",
 		description:
-			"Use the configured Mnemopi LLM mode (smol or remote); no local model download or on-device inference.",
+			"Use the online model: the TINY role from /models when set, otherwise pi/smol. No local model download or on-device inference.",
 	},
 	...TINY_MEMORY_LOCAL_MODELS.map(model => ({
 		value: model.key,
@@ -245,8 +246,9 @@ export type AutoThinkingModelKey = TinyMemoryModelKey;
 export const AUTO_THINKING_MODEL_OPTIONS = [
 	{
 		value: ONLINE_AUTO_THINKING_MODEL_KEY,
-		label: "Online (smol)",
-		description: "Classify prompt difficulty with the online smol model; no local download or on-device inference.",
+		label: "Online (TINY role, else smol)",
+		description:
+			"Classify prompt difficulty online with the TINY role model (set one in /models) or pi/smol; no local download or on-device inference.",
 	},
 	...TINY_MEMORY_LOCAL_MODELS.map(model => ({
 		value: model.key,

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
@@ -173,14 +196,15 @@ export function normalizeGeneratedTitle(value: string | null | undefined, source
  * (`TinyVMM` → `tinyvmm`). The user's message is the source of truth, so per
  * title token:
  *  1. typed verbatim in the message → keep it (the user established the casing);
- *  2. else the message has the same word with *distinctive* casing
- *     (`TinyVMM`, `iOS`, `API`) → adopt the user's casing (restoration);
+ *  2. else the message has the same word with *distinctive* mixed casing
+ *     (`TinyVMM`, `iOS`, `IDs`) → adopt the user's casing (restoration);
  *  3. else it's a camelCase artifact (lowercase word + stray interior capital,
  *     `dAemon`) the user never wrote → lowercase it;
  *  4. else leave it — preserves model-cased proper nouns like `GitHub`, `OAuth`.
  *
- * Restoration is limited to distinctively cased source tokens so a sentence that
- * merely *starts* with `For` can't force a mid-title `for` to `For`.
+ * Restoration is limited to distinctively *mixed*-cased source tokens: a sentence
+ * that merely *starts* with `For` can't force a mid-title `for` to `For`, and
+ * emphatic all-caps (`ALL ERROR HANDLING`) is never re-shouted over sentence case.
  */
 function reconcileTitleCasing(title: string, sourceText: string): string {
 	const verbatim = new Set<string>();
@@ -200,10 +224,16 @@ function reconcileTitleCasing(title: string, sourceText: string): string {
 	});
 }
 
-/** Casing richer than a leading capital — interior or repeated uppercase
- *  (`TinyVMM`, `iOS`, `API`). Worth restoring from the user's message. */
+/** Mixed-case identifier the user cased deliberately (`TinyVMM`, `iOS`, `IDs`):
+ *  an interior/repeated capital plus at least one lowercase letter. Only these
+ *  are restored when the model flattens them.
+ *
+ *  Pure all-caps is intentionally excluded. The model preserves its own acronyms
+ *  verbatim regardless, so restoring all-caps from the source would only ever
+ *  re-shout emphatic input (`ALL ERROR HANDLING`, `FIX THE BUG`) over the
+ *  sentence case the prompt asks for. */
 function isDistinctiveCasing(token: string): boolean {
-	return /\p{L}\p{Lu}/u.test(token);
+	return /\p{Ll}/u.test(token) && /\p{L}\p{Lu}/u.test(token);
 }
 
 /** A lowercase word carrying a stray interior capital (`dAemon`, `cReate`): the