@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/extensions/zentui/thinking-experimental.ts

@@ -18,7 +18,13 @@ import {
 	type PrototypePatchRegistration,
 } from "./prototype-patch-registry";
 import { formatThinkingStatus, thinkingStatusLabels } from "./thinking-status";
-import { parseThinkingSteps, type ThinkingStep } from "./thinking-steps";
+import {
+	parseThinkingStepsResult,
+	THINKING_STEPS_MAX_INPUT_LENGTH,
+	THINKING_STEPS_MAX_STEPS,
+	type ThinkingStep,
+	type ThinkingStepsParseResult,
+} from "./thinking-steps";
 
 /*
  * The rendered-row folding and lifecycle below are adapted from
@@ -56,6 +62,7 @@ const MAX_TIMINGS = 256;
 type PatchableAssistant = {
 	contentContainer?: { children?: Component[] };
 	hideThinkingBlock?: boolean;
+	thinkingVisibilityOverrides?: Map<number, boolean>;
 	isStreaming?: boolean;
 };
 
@@ -86,11 +93,13 @@ type HiddenState = { own: boolean; value: boolean | undefined };
 
 type TrackedState = {
 	message: AssistantMessage;
+	timestamp: number | undefined;
 	args: unknown[];
 	predecessor: (this: unknown, ...args: unknown[]) => unknown;
 	incomplete: boolean;
 	nativeHidden: HiddenState;
 	folded: boolean;
+	structuralCache: ThinkingRunParseCache;
 };
 
 type Timing = { startedAt?: number; completedAt?: number };
@@ -209,6 +218,8 @@ function croppedMarkdownRow(markdown: Markdown, source: string, width: number):
 /** A width-bounded private replacement for one native contiguous thinking run. */
 export class ThinkingStepsRows implements Component {
 	private readonly title: Markdown;
+	// Content and presentation are constructor-fixed; retain only the last successful layout.
+	private renderedCache: { width: number; theme: AccentTheme; rows: string[] } | undefined;
 	private readonly labels: Array<{ source: string; markdown: Markdown }>;
 
 	constructor(
@@ -218,6 +229,8 @@ export class ThinkingStepsRows implements Component {
 		private readonly mode: StructuralThinkingMode,
 		private readonly incomplete: boolean,
 		private readonly getTheme: () => AccentTheme,
+		private readonly onPresentation?: (visible: boolean) => void,
+		private readonly onInvalidate?: () => void,
 	) {
 		const selected = mode === "rail" ? steps : steps.slice(-5);
 		this.title = new Markdown(
@@ -234,14 +247,30 @@ export class ThinkingStepsRows implements Component {
 		}));
 	}
 
+	private renderNative(width: number): string[] {
+		this.renderedCache = undefined;
+		this.onPresentation?.(false);
+		return this.native.render(width);
+	}
+
 	render(width: number): string[] {
 		try {
+			let theme: AccentTheme | undefined;
+			const cached = this.renderedCache;
+			if (cached?.width === width) {
+				// The host theme getter is a read-only lookup, including on cache hits.
+				theme = this.getTheme();
+				if (cached.theme === theme) {
+					this.onPresentation?.(true);
+					return [...cached.rows];
+				}
+			}
 			const outer = this.shape.paddingX;
 			const innerWidth = Math.floor(width) - outer * 2;
 			const titleConnector = this.mode === "rail" ? "│ " : "┆ ";
 			const titleBudget = innerWidth - visibleWidth(titleConnector);
 			const title = croppedMarkdownRow(this.title, "**Thinking**", titleBudget);
-			if (!title) return this.native.render(width);
+			if (!title) return this.renderNative(width);
 			const renderedLabels: Array<{ connector: string; label: string }> = [];
 			for (const [index, value] of this.labels.entries()) {
 				const final = index === this.labels.length - 1;
@@ -257,10 +286,10 @@ export class ThinkingStepsRows implements Component {
 							: "├─ · ";
 				const budget = innerWidth - visibleWidth(connector);
 				const label = croppedMarkdownRow(value.markdown, value.source, budget);
-				if (!label) return this.native.render(width);
+				if (!label) return this.renderNative(width);
 				renderedLabels.push({ connector, label });
 			}
-			const theme = this.getTheme();
+			theme ??= this.getTheme();
 			const left = " ".repeat(outer);
 			const right = " ".repeat(outer);
 			const rows = [
@@ -269,13 +298,19 @@ export class ThinkingStepsRows implements Component {
 					({ connector, label }) => `${left}${theme.fg("accent", connector)}${label}${right}`,
 				),
 			];
-			return rows.every((row) => visibleWidth(row) <= width) ? rows : this.native.render(width);
+			if (!rows.every((row) => visibleWidth(row) <= width)) return this.renderNative(width);
+			this.renderedCache = { width, theme, rows };
+			this.onPresentation?.(true);
+			// Containers and decorators may mutate their returned array.
+			return [...rows];
 		} catch {
-			return this.native.render(width);
+			return this.renderNative(width);
 		}
 	}
 
 	invalidate(): void {
+		this.renderedCache = undefined;
+		this.onInvalidate?.();
 		this.native.invalidate();
 		this.title.invalidate();
 		for (const label of this.labels) label.markdown.invalidate();
@@ -299,6 +334,8 @@ class FoldContext {
 	private preparedWidth: number | undefined;
 	private allocations = new Map<FoldedThinkingSection, string[]>();
 	private hidden = false;
+	private headerMarkdown: Markdown | undefined;
+	private headerText: string | undefined;
 
 	constructor(
 		readonly incomplete: boolean,
@@ -336,19 +373,28 @@ class FoldContext {
 
 	headerRows(width: number): string[] {
 		this.prepare(width);
-		return new Markdown(
-			this.header(this.hidden),
-			this.template.paddingX,
-			this.template.paddingY,
-			this.template.theme,
-			this.template.defaultTextStyle,
-			this.template.options,
-		).render(width);
+		const text = this.header(this.hidden);
+		if (!this.headerMarkdown) {
+			this.headerMarkdown = new Markdown(
+				text,
+				this.template.paddingX,
+				this.template.paddingY,
+				this.template.theme,
+				this.template.defaultTextStyle,
+				this.template.options,
+			);
+		} else if (text !== this.headerText) {
+			this.headerMarkdown.setText(text);
+		}
+		this.headerText = text;
+		return this.headerMarkdown.render(width);
 	}
 
 	invalidate(): void {
 		this.preparedWidth = undefined;
 		this.allocations.clear();
+		this.headerMarkdown = undefined;
+		this.headerText = undefined;
 	}
 }
 
@@ -462,13 +508,12 @@ function trailingDescriptors(message: AssistantMessage): NativeChildDescriptor[]
 }
 
 /**
- * Mirrors the visible child layouts shipped by the supported Pi hosts. Pi 0.83+
- * coalesces a contiguous thinking run; Pi 0.80.5 emitted one section per block.
+ * Mirrors the supported Pi child layout, which coalesces contiguous thinking runs.
  * Tool calls emit no child here, but still terminate a thinking run and suppress
  * trailing errors, so iteration over the original ordered content is required.
  */
 function nativeChildLayouts(message: AssistantMessage): NativeChildDescriptor[][] {
-	const build = (coalesceThinking: boolean): NativeChildDescriptor[] => {
+	const build = (): NativeChildDescriptor[] => {
 		const descriptors: NativeChildDescriptor[] = [];
 		let nextRun = 0;
 		let contiguousRun: number | undefined;
@@ -487,14 +532,6 @@ function nativeChildLayouts(message: AssistantMessage): NativeChildDescriptor[][
 			}
 			const run = contiguousRun ?? nextRun++;
 			contiguousRun = run;
-			if (!coalesceThinking) {
-				const source = content.thinking.trim();
-				if (source) {
-					descriptors.push({ kind: "markdown", source, thinkingRun: run });
-					if (hasVisibleContentAfter(message, index + 1)) descriptors.push({ kind: "spacer" });
-				}
-				continue;
-			}
 			const blocks: string[] = [];
 			for (; index < message.content.length; index += 1) {
 				const next = message.content[index];
@@ -509,9 +546,7 @@ function nativeChildLayouts(message: AssistantMessage): NativeChildDescriptor[][
 		}
 		return [...descriptors, ...trailingDescriptors(message)];
 	};
-	const coalesced = build(true);
-	const legacy = build(false);
-	return JSON.stringify(coalesced) === JSON.stringify(legacy) ? [coalesced] : [coalesced, legacy];
+	return [build()];
 }
 
 function plainTextMarker(text: string): string {
@@ -522,36 +557,75 @@ function exactConstructor(component: Component, expected: { prototype: object })
 	return Object.getPrototypeOf(component) === expected.prototype;
 }
 
+/**
+ * Pi 0.85 wraps each thinking run in MouseRegion for click-to-toggle.
+ * Duck-type so we do not depend on MouseRegion being a public export.
+ */
+function unwrapMouseRegion(component: Component): Component {
+	const outer = component as unknown as { child?: unknown; onMouse?: unknown };
+	const inner = outer.child;
+	if (
+		typeof outer.onMouse !== "function" ||
+		!inner ||
+		typeof inner !== "object" ||
+		typeof (inner as Component).render !== "function"
+	) {
+		return component;
+	}
+	return inner as Component;
+}
+
 function matchNativeLayout(
 	children: Component[],
 	descriptors: NativeChildDescriptor[],
+	hiddenRuns?: Map<number, boolean>,
 ): ThinkingMarkdownLayout | undefined {
 	if (children.length !== descriptors.length) return undefined;
 	const thinking: ThinkingMarkdownMatch[] = [];
+	let nativeThinkingRun = -1;
+	let previousThinkingRun: number | undefined;
 	for (let index = 0; index < descriptors.length; index += 1) {
 		const child = children[index];
 		const descriptor = descriptors[index];
 		if (!child || !descriptor) return undefined;
+		const visible = unwrapMouseRegion(child);
 		if (descriptor.kind === "spacer") {
-			if (!exactConstructor(child, Spacer) || (child as unknown as { lines?: unknown }).lines !== 1)
+			if (
+				!exactConstructor(visible, Spacer) ||
+				(visible as unknown as { lines?: unknown }).lines !== 1
+			) {
 				return undefined;
+			}
 			continue;
 		}
 		if (descriptor.kind === "text") {
-			if (!exactConstructor(child, Text)) return undefined;
-			const text = (child as unknown as { text?: unknown }).text;
+			if (!exactConstructor(visible, Text)) return undefined;
+			const text = (visible as unknown as { text?: unknown }).text;
 			if (typeof text !== "string") return undefined;
 			const marker = plainTextMarker(text);
 			if (!descriptor.markers.includes(marker)) return undefined;
 			continue;
 		}
-		if (!exactConstructor(child, Markdown)) return undefined;
-		const shape = markdownShape(child as Markdown);
+		// Pi numbers only rendered runs; structural IDs also count empty runs.
+		if (descriptor.thinkingRun !== undefined && descriptor.thinkingRun !== previousThinkingRun) {
+			nativeThinkingRun += 1;
+			previousThinkingRun = descriptor.thinkingRun;
+		}
+		// A native per-run click can hide one section while others remain decorated.
+		if (
+			descriptor.thinkingRun !== undefined &&
+			hiddenRuns?.get(nativeThinkingRun) === true &&
+			visible !== child &&
+			exactConstructor(visible, Text)
+		)
+			continue;
+		if (!exactConstructor(visible, Markdown)) return undefined;
+		const shape = markdownShape(visible as Markdown);
 		if (!shape || shape.text !== descriptor.source) return undefined;
 		if (descriptor.thinkingRun !== undefined) {
 			thinking.push({
 				index,
-				markdown: child as Markdown,
+				markdown: visible as Markdown,
 				shape,
 				run: descriptor.thinkingRun,
 			});
@@ -563,10 +637,11 @@ function matchNativeLayout(
 function thinkingMarkdownLayout(
 	children: Component[],
 	message: AssistantMessage,
+	hiddenRuns?: Map<number, boolean>,
 ): ThinkingMarkdownLayout | undefined {
 	for (const descriptors of nativeChildLayouts(message)) {
-		const layout = matchNativeLayout(children, descriptors);
-		if (layout?.matches.length) return layout;
+		const layout = matchNativeLayout(children, descriptors, hiddenRuns);
+		if (layout) return layout;
 	}
 	return undefined;
 }
@@ -609,6 +684,72 @@ function activeThinkingRun(message: AssistantMessage, incomplete: boolean): numb
 	return contiguousRun;
 }
 
+type ThinkingRunParseEntry = {
+	source: string;
+	result: ThinkingStepsParseResult;
+	active: boolean;
+	token: symbol;
+	presented: boolean;
+	labels: readonly string[];
+};
+
+/** Per-component source budget, shared across runs; never retains rendered/theme-colored rows. */
+class ThinkingRunParseCache {
+	private entries = new Map<number, ThinkingRunParseEntry>();
+
+	clear(): void {
+		this.entries.clear();
+	}
+
+	retainRuns(runs: ReadonlySet<number>): void {
+		for (const run of this.entries.keys()) if (!runs.has(run)) this.entries.delete(run);
+	}
+
+	presentationListener(run: number, token: symbol): (visible: boolean) => void {
+		return (visible) => {
+			const entry = this.entries.get(run);
+			if (entry?.token === token) entry.presented = visible;
+		};
+	}
+
+	parse(run: number, source: string, active: boolean): ThinkingRunParseEntry | undefined {
+		const previous = this.entries.get(run);
+		if (previous?.source === source && previous.active === active) return previous;
+		const result = parseThinkingStepsResult(source);
+		this.entries.delete(run);
+		if (!result) return undefined;
+		const entry: ThinkingRunParseEntry = {
+			source,
+			result,
+			active,
+			token: Symbol(),
+			presented: false,
+			labels: result.steps.map((step) => step.label),
+		};
+		// Only an already displayed, append-only active run may survive unfinished syntax.
+		// Matching every label also prevents a newly appended unsafe label being suppressed.
+		if (
+			active &&
+			previous?.active &&
+			previous.presented &&
+			source.startsWith(previous.source) &&
+			previous.labels.length === entry.labels.length &&
+			entry.labels.every((label, index) => label === previous.labels[index])
+		)
+			entry.presented = true;
+		this.entries.set(run, entry);
+		let size = 0;
+		for (const value of this.entries.values()) size += value.source.length;
+		while (size > THINKING_STEPS_MAX_INPUT_LENGTH || this.entries.size > THINKING_STEPS_MAX_STEPS) {
+			const oldest = this.entries.entries().next().value;
+			if (!oldest) break;
+			size -= oldest[1].source.length;
+			this.entries.delete(oldest[0]);
+		}
+		return entry;
+	}
+}
+
 function replaceThinkingChildren(
 	instance: PatchableAssistant,
 	message: AssistantMessage,
@@ -616,15 +757,19 @@ function replaceThinkingChildren(
 	incomplete: boolean,
 	header: (hidden: boolean) => string,
 	getTheme: () => AccentTheme,
+	structuralCache: ThinkingRunParseCache,
 ): boolean {
 	const owned = writableOwnChildren(instance);
 	if (!owned) return false;
 	const { container, children } = owned;
-	const layout = thinkingMarkdownLayout(children, message);
+	const layout = thinkingMarkdownLayout(children, message, instance.thinkingVisibilityOverrides);
 	if (!layout) return false;
+	structuralCache.retainRuns(new Set(layout.matches.map((match) => match.run)));
+	if (layout.matches.length === 0) return true;
 	const replacements = new Map<number, Component>();
 	const removals = new Set<number>();
 	if (mode === "streaming") {
+		structuralCache.clear();
 		const template = layout.matches[0]?.shape;
 		if (!template) return false;
 		const context = new FoldContext(incomplete, header, template);
@@ -647,20 +792,23 @@ function replaceThinkingChildren(
 			const last = matches.at(-1);
 			if (!first || !last) continue;
 			const source = matches.map((match) => match.shape.text).join("\n\n");
-			const steps = parseThinkingSteps(source);
-			if (!steps?.length) continue;
+			const entry = structuralCache.parse(run, source, run === activeRun);
+			if (!entry || (entry.result.unfinished && (!entry.active || !entry.presented))) continue;
+			const steps = entry.result.steps;
 			const nativeChildren = children.slice(first.index, last.index + 1);
 			const native =
 				nativeChildren.length === 1 ? first.markdown : new NativeThinkingRun(nativeChildren);
 			replacements.set(
 				first.index,
-				createThinkingStepsRows(
+				new ThinkingStepsRows(
 					native,
 					{ ...first.shape, text: source },
 					steps,
 					mode,
 					run === activeRun,
 					getTheme,
+					structuralCache.presentationListener(run, entry.token),
+					() => structuralCache.clear(),
 				),
 			);
 			for (let index = first.index + 1; index <= last.index; index += 1) removals.add(index);
@@ -669,7 +817,17 @@ function replaceThinkingChildren(
 	if (replacements.size === 0) return true;
 	const nextChildren = children.flatMap((child, index) => {
 		const replacement = replacements.get(index);
-		if (replacement) return [replacement];
+		if (replacement) {
+			// Keep the native callback and child-first mouse dispatch. The replacement
+			// retains the inner Markdown, not this wrapper, so no render cycle forms.
+			if (unwrapMouseRegion(child) !== child) {
+				const slot = Object.getOwnPropertyDescriptor(child, "child");
+				if (!slot || !("value" in slot) || !slot.writable) return [child];
+				(child as unknown as { child: Component }).child = replacement;
+				return [child];
+			}
+			return [replacement];
+		}
 		return removals.has(index) ? [] : [child];
 	});
 	container.children = nextChildren;
@@ -843,7 +1001,7 @@ export class ThinkingExperimentalController {
 		this.resourceToken += 1;
 		this.streamingUnavailableReason = undefined;
 		this.streamingListenerPoisoned = false;
-		if (ctx.mode === "tui" && ctx.hasUI) this.context = ctx;
+		if (ctx.hasUI && (ctx.mode === undefined || ctx.mode === "tui")) this.context = ctx;
 		this.startup = { ...this.getConfig() };
 		this.restartRequired = false;
 		this.activeMode = undefined;
@@ -919,6 +1077,7 @@ export class ThinkingExperimentalController {
 		this.expanded = false;
 		this.activeMode = desired.mode;
 		this.restartRequired = false;
+		for (const [, state] of this.trackedEntries()) state.structuralCache.clear();
 		this.rerenderTracked();
 		const result = this.liveTransitionResult(desired.mode);
 		if (!result.applied || streamingCleanupSucceeded) return result;
@@ -1060,6 +1219,7 @@ export class ThinkingExperimentalController {
 										throw new Error("theme unavailable");
 									return theme;
 								},
+								trackedState.structuralCache,
 							)
 						) {
 							this.failShape("Pi's private assistant renderer shape is incompatible");
@@ -1094,13 +1254,24 @@ export class ThinkingExperimentalController {
 		incomplete: boolean,
 		nativeHidden: HiddenState,
 	): TrackedState {
+		const previous = this.states.get(component);
+		const structuralCache =
+			previous &&
+			(previous.timestamp !== undefined
+				? previous.timestamp === messageTimestamp(message)
+				: previous.message === message) &&
+			previous.incomplete === incomplete
+				? previous.structuralCache
+				: new ThinkingRunParseCache();
 		const trackedState: TrackedState = {
 			message,
+			timestamp: messageTimestamp(message),
 			args: [...args],
 			predecessor,
 			incomplete,
 			nativeHidden,
 			folded: false,
+			structuralCache,
 		};
 		this.states.set(component, trackedState);
 		let reference = this.references.get(component);
@@ -1357,7 +1528,7 @@ export class ThinkingExperimentalController {
 			)
 				return;
 			if (this.checkDisplacement()) return;
-			this.rerenderActive();
+			this.refreshActiveHeaders();
 			this.reconcileTimer();
 		}, 1000);
 	}
@@ -1519,6 +1690,7 @@ export class ThinkingExperimentalController {
 										throw new Error("theme unavailable");
 									return theme;
 								},
+								state.structuralCache,
 							)
 						) {
 							this.failShape("Pi's private assistant renderer shape is incompatible");
@@ -1552,9 +1724,24 @@ export class ThinkingExperimentalController {
 		if (processed > 0) this.requestHostRender();
 	}
 
-	private rerenderActive(): void {
-		const entries = this.activeEntries();
-		this.lastTimerWork = this.rerenderEntries(entries);
+	private refreshActiveHeaders(): void {
+		// Elapsed headers are evaluated at render time. Rebuilding native children here
+		// would discard their Markdown/layout caches even though no content changed.
+		this.lastTimerWork = this.expanded
+			? 0
+			: this.activeEntries().filter(([component, state]) => {
+					try {
+						return (
+							state.folded &&
+							writableOwnChildren(component as PatchableAssistant)?.children.some(
+								(child) => unwrapMouseRegion(child) instanceof FoldedThinkingSection,
+							)
+						);
+					} catch {
+						// Foreign/stale children are not ours to repair on an elapsed-only tick.
+						return false;
+					}
+				}).length;
 		if (this.lastTimerWork > 0) this.requestHostRender();
 	}
 
@@ -1729,6 +1916,7 @@ export class ThinkingExperimentalController {
 		const completedEntries = this.activeEntries().filter(([, state]) => {
 			if (messageTimestamp(state.message) !== timestamp) return false;
 			state.incomplete = false;
+			state.structuralCache.clear();
 			return true;
 		});
 		for (const [component] of completedEntries) {

package/dist/extensions/pi-zentui/extensions/zentui/thinking-steps.ts

@@ -18,7 +18,13 @@ type MutableStep = {
 };
 
 type StructuralLabel = { label: string };
-type OpaqueBlock = { end: number; malformed: boolean };
+type OpaqueBlock = { end: number; malformed: boolean; unfinished?: boolean };
+
+export type ThinkingStepsParseResult = Readonly<{
+	steps: readonly ThinkingStep[];
+	/** Only an unclosed recognized fence/math body; all source/label limits still passed. */
+	unfinished: boolean;
+}>;
 
 const meaningfulLabelPattern = /[\p{L}\p{N}\p{Extended_Pictographic}]/u;
 
@@ -49,7 +55,7 @@ function fenceBlock(lines: readonly string[], start: number): OpaqueBlock | unde
 	for (let index = start + 1; index < lines.length; index += 1) {
 		if (closing.test(lines[index] ?? "")) return { end: index, malformed: false };
 	}
-	return { end: lines.length - 1, malformed: true };
+	return { end: lines.length - 1, malformed: false, unfinished: true };
 }
 
 function mathBlock(lines: readonly string[], start: number): OpaqueBlock | undefined {
@@ -64,7 +70,7 @@ function mathBlock(lines: readonly string[], start: number): OpaqueBlock | undef
 	for (let index = start + 1; index < lines.length; index += 1) {
 		if (close.test(lines[index] ?? "")) return { end: index, malformed: false };
 	}
-	return { end: lines.length - 1, malformed: true };
+	return { end: lines.length - 1, malformed: false, unfinished: true };
 }
 
 function isTopLevelProse(line: string): boolean {
@@ -107,7 +113,7 @@ function finishSteps(steps: MutableStep[]): ThinkingStep[] | undefined {
 }
 
 /** Parse source-level structure; fenced and display-math blocks remain opaque bodies. */
-export function parseThinkingSteps(markdown: string): readonly ThinkingStep[] | undefined {
+export function parseThinkingStepsResult(markdown: string): ThinkingStepsParseResult | undefined {
 	if (!markdown || markdown.length > THINKING_STEPS_MAX_INPUT_LENGTH) return undefined;
 	const source = sanitizeSgrOnlySourceText(markdown.replace(/\r\n/g, "\n"));
 	if (source === undefined || !source.trim()) return undefined;
@@ -116,6 +122,7 @@ export function parseThinkingSteps(markdown: string): readonly ThinkingStep[] |
 	const steps: MutableStep[] = [];
 	let current: MutableStep | undefined;
 	let paragraphBoundary = true;
+	let unfinished = false;
 	const startStep = (label: string) => {
 		if (steps.length >= THINKING_STEPS_MAX_STEPS) return false;
 		current = { number: steps.length + 1, label, bodyLines: [] };
@@ -134,6 +141,7 @@ export function parseThinkingSteps(markdown: string): readonly ThinkingStep[] |
 		const opaque = fenceBlock(lines, index) ?? mathBlock(lines, index);
 		if (opaque) {
 			if (opaque.malformed || !current) return undefined;
+			unfinished = opaque.unfinished === true;
 			current.bodyLines.push(...lines.slice(index, opaque.end + 1));
 			index = opaque.end;
 			continue;
@@ -151,5 +159,12 @@ export function parseThinkingSteps(markdown: string): readonly ThinkingStep[] |
 		current.bodyLines.push(line);
 	}
 	if (steps.length === 0) return undefined;
-	return finishSteps(steps);
+	const finished = finishSteps(steps);
+	return finished ? { steps: finished, unfinished } : undefined;
+}
+
+/** Finalized/standalone parsing never accepts an unfinished opaque block. */
+export function parseThinkingSteps(markdown: string): readonly ThinkingStep[] | undefined {
+	const result = parseThinkingStepsResult(markdown);
+	return result && !result.unfinished ? result.steps : undefined;
 }