@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/extensions/zentui/interaction-summary.ts

@@ -1,13 +1,20 @@
 import type { AssistantMessage, AssistantMessageEvent } from "@earendil-works/pi-ai";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import type { ColorSource, ColorSpec } from "./config";
+import { workingLineColor } from "./component-colors";
+import type {
+	ColorSource,
+	ColorSpec,
+	PolishedTuiColors,
+	WorkingLineComponentConfig,
+} from "./config";
 import { formatCount, formatElapsedDuration } from "./format";
 import { isSafeSgrStylePrefix } from "./style";
+import { normalizeTurnSummaryFormat, renderTurnSummaryFormat } from "./turn-summary-format";
 import { renderWorkingLineHigh } from "./working-line";
 
 export const TURN_SUMMARY_ENTRY_TYPE = "zentui-turn-summary";
-const TURN_SUMMARY_VERSION = 3;
+const TURN_SUMMARY_VERSION = 4;
 const SGR_RESET = "\x1b[0m";
 
 export type InteractionTokens = Readonly<{ input: number; output: number }>;
@@ -31,7 +38,18 @@ export type TurnSummaryDataV3 = SummaryBase & {
 	thoughtDurationMs: number;
 	stylePrefix: string;
 };
-export type TurnSummaryData = TurnSummaryDataV1 | TurnSummaryDataV2 | TurnSummaryDataV3;
+export type TurnSummaryDataV4 = SummaryBase & {
+	version: 4;
+	thoughtDurationMs: number;
+	stylePrefix: string;
+	format: string;
+	averageTokenRate?: number;
+};
+export type TurnSummaryData =
+	| TurnSummaryDataV1
+	| TurnSummaryDataV2
+	| TurnSummaryDataV3
+	| TurnSummaryDataV4;
 export type TurnSummaryMetrics = SummaryBase & { thoughtDurationMs: number };
 
 type Interval = { start: number; end: number };
@@ -999,8 +1017,30 @@ export function isTurnSummaryData(value: unknown): value is TurnSummaryData {
 			isSafeSgrStylePrefix(record.stylePrefix)
 		);
 	}
+	if (record.version === TURN_SUMMARY_VERSION) {
+		return (
+			hasExactKeys(record, [
+				"version",
+				"durationMs",
+				"thoughtDurationMs",
+				"input",
+				"output",
+				"stylePrefix",
+				"format",
+				...(Object.hasOwn(record, "averageTokenRate") ? ["averageTokenRate"] : []),
+			]) &&
+			isNonnegativeSafeInteger(record.thoughtDurationMs) &&
+			(record.stylePrefix === "" || isSafeSgrStylePrefix(record.stylePrefix)) &&
+			typeof record.format === "string" &&
+			record.format === normalizeTurnSummaryFormat(record.format) &&
+			(!Object.hasOwn(record, "averageTokenRate") ||
+				(typeof record.averageTokenRate === "number" &&
+					Number.isFinite(record.averageTokenRate) &&
+					record.averageTokenRate >= 0))
+		);
+	}
 	return (
-		record.version === TURN_SUMMARY_VERSION &&
+		record.version === 3 &&
 		hasExactKeys(record, [
 			"version",
 			"durationMs",
@@ -1015,6 +1055,7 @@ export function isTurnSummaryData(value: unknown): value is TurnSummaryData {
 }
 
 export function formatTurnSummary(data: TurnSummaryData | TurnSummaryMetrics): string {
+	if ("version" in data && data.version === 4) return renderTurnSummaryFormat(data.format, data);
 	const thought =
 		"thoughtDurationMs" in data && data.thoughtDurationMs > 0
 			? ` · thought for ${formatElapsedDuration(data.thoughtDurationMs)}`
@@ -1029,7 +1070,7 @@ export function renderTurnSummaryEntry(
 ): Text | undefined {
 	if (!isTurnSummaryData(entry.data)) return undefined;
 	const text = formatTurnSummary(entry.data);
-	if (entry.data.version === 2 || entry.data.version === 3) {
+	if (entry.data.version === 2 || entry.data.version === 3 || entry.data.version === 4) {
 		return new Text(`${entry.data.stylePrefix}${text}${SGR_RESET}`, 0, 0);
 	}
 	const options = (themeOptions ?? {}) as {
@@ -1047,3 +1088,27 @@ export function renderTurnSummaryEntry(
 		0,
 	);
 }
+
+/** Snapshot only the persisted summary's style; never mutate the live Working palette. */
+export function createTurnSummaryData(
+	metrics: TurnSummaryMetrics,
+	averageTokenRate: number | undefined,
+	theme: Pick<Theme, "fg">,
+	config: WorkingLineComponentConfig,
+	colors: PolishedTuiColors,
+): TurnSummaryDataV4 {
+	const sentinel = "\u{f0000}";
+	const style = workingLineColor(config, colors, "turnSummary");
+	const rendered = renderWorkingLineHigh(theme, config.colorSource, style, sentinel);
+	const position = rendered.indexOf(sentinel);
+	const prefix = position >= 0 ? rendered.slice(0, position) : "";
+	return {
+		version: 4,
+		...metrics,
+		format: normalizeTurnSummaryFormat(config.turnSummaryFormat),
+		stylePrefix: style?.trim() === "" ? "" : isSafeSgrStylePrefix(prefix) ? prefix : "\x1b[1;36m",
+		...(averageTokenRate !== undefined && Number.isFinite(averageTokenRate) && averageTokenRate >= 0
+			? { averageTokenRate }
+			: {}),
+	};
+}

package/dist/extensions/pi-zentui/extensions/zentui/layered-editor.ts

@@ -0,0 +1,55 @@
+/**
+ * Records that a Zentui editor instance is still visible beneath a foreign predecessor-preserving
+ * wrapper (`setEditorComponent((tui, theme, kb) => predecessor(tui, theme, kb))`).
+ *
+ * This is deliberately NOT installation ownership: Zentui does not own the outer factory, must not
+ * replace or restore it, and keeps this record across ownership clearing. It only answers
+ * "may a surface Zentui rendered still be on screen?" for read-only consumers such as usage demand
+ * and redraw requests. The record is valid only while the outer factory observed at construction is
+ * still the current editor factory, so any replacement of the chain invalidates it.
+ *
+ * Construction alone cannot authorize hiding the Working row: its controller additionally requires
+ * a focused editor that has rendered safe border geometry. A wrapper that renders then discards those
+ * rows remains undetectable; supporting such wrappers requires an explicit host visibility contract.
+ */
+export class LayeredEditorConsumer<Factory, Editor = unknown> {
+	private record?: {
+		outerFactory: Factory;
+		generation: number;
+		editor: Editor;
+		requestRender: () => void;
+	};
+
+	constructor(private readonly isCurrentGeneration: (generation: number) => boolean) {}
+
+	attach(
+		outerFactory: Factory,
+		generation: number,
+		editor: Editor,
+		requestRender: () => void,
+	): void {
+		this.record = { outerFactory, generation, editor, requestRender };
+	}
+
+	detach(): void {
+		this.record = undefined;
+	}
+
+	editorVisibleThrough(currentFactory: Factory | undefined): Editor | undefined {
+		const record = this.record;
+		if (!record) return undefined;
+		if (!this.isCurrentGeneration(record.generation) || record.outerFactory !== currentFactory) {
+			this.record = undefined;
+			return undefined;
+		}
+		return record.editor;
+	}
+
+	isVisibleThrough(currentFactory: Factory | undefined): boolean {
+		return this.editorVisibleThrough(currentFactory) !== undefined;
+	}
+
+	requestRender(currentFactory: Factory | undefined): void {
+		if (this.isVisibleThrough(currentFactory)) this.record?.requestRender();
+	}
+}

package/dist/extensions/pi-zentui/extensions/zentui/live-context.ts

@@ -34,6 +34,7 @@ export class LiveContextController {
 	private readonly lifecycle: SessionLifecycle;
 	private readonly requestRender: () => void;
 	private override: LiveContextOverride | undefined;
+	private overrideGeneration: number | undefined;
 	private cancelScheduledRender: (() => void) | undefined;
 	private scheduledGeneration: number | undefined;
 
@@ -49,8 +50,11 @@ export class LiveContextController {
 	update(message: unknown): boolean {
 		const next = liveContextFromMessage(message);
 		if (!next || !this.lifecycle.isCurrent()) return false;
-		this.override = next;
 		const generation = this.lifecycle.currentGeneration();
+		if (this.overrideGeneration === generation && this.override?.tokens === next.tokens)
+			return false;
+		this.override = next;
+		this.overrideGeneration = generation;
 		if (this.cancelScheduledRender && this.scheduledGeneration !== generation) {
 			this.cancelScheduledRender = undefined;
 			this.scheduledGeneration = undefined;
@@ -68,6 +72,7 @@ export class LiveContextController {
 
 	clear(): void {
 		this.override = undefined;
+		this.overrideGeneration = undefined;
 		this.cancelScheduledRender?.();
 		this.cancelScheduledRender = undefined;
 		this.scheduledGeneration = undefined;

package/dist/extensions/pi-zentui/extensions/zentui/live-metadata-demand.ts

@@ -0,0 +1,72 @@
+import {
+	FOOTER_FORMAT_ALIASES,
+	FOOTER_FORMAT_VARIABLES,
+	hasUnsupportedComponentStyle,
+	OPENCODE_FORMAT_VARIABLES,
+	type ZentuiConfig,
+} from "./config";
+import { editorMetadataReferences } from "./custom-variable-demand";
+import { normalizeTemplateVariables } from "./custom-variable-format";
+import { compiledFooterFormat } from "./footer-format";
+import { isHostTemplateVariable } from "./host-template-values";
+import { normalizeMinimalistVariables } from "./minimalist-template";
+
+export function editorHostReferences(config: ZentuiConfig): ReadonlySet<string> {
+	const editor = config.components.editor;
+	if (
+		!editor.enabled ||
+		hasUnsupportedComponentStyle(config, "editor") ||
+		editor.style === "accent-rail"
+	)
+		return new Set();
+	const aliases =
+		editor.style === "minimalist"
+			? normalizeMinimalistVariables(editor.styles.minimalist.variables)
+			: normalizeTemplateVariables(
+					editor.styles[editor.style].variables,
+					OPENCODE_FORMAT_VARIABLES,
+				);
+	return new Set(
+		[...editorMetadataReferences(config)].filter(
+			(name) => isHostTemplateVariable(name) && !Object.hasOwn(aliases, name),
+		),
+	);
+}
+export function footerHostReferences(config: ZentuiConfig): ReadonlySet<string> {
+	const footer = config.components.footer;
+	if (footer.style !== "starship" || hasUnsupportedComponentStyle(config, "footer"))
+		return new Set();
+	const style = footer.styles.starship;
+	const aliases = normalizeTemplateVariables(style.variables, [
+		...FOOTER_FORMAT_VARIABLES,
+		...Object.keys(FOOTER_FORMAT_ALIASES),
+	]);
+	const references = [
+		...compiledFooterFormat(style.format).references,
+		...(style.responsive ? compiledFooterFormat(style.compactFormat).references : []),
+	];
+	return new Set(
+		references.filter((name) => isHostTemplateVariable(name) && !Object.hasOwn(aliases, name)),
+	);
+}
+export type LiveMetadataDemand = Readonly<{ github: boolean; tokenRate: boolean }>;
+/** Ownership is proved by orchestration, never inferred from a configured style alone. */
+export function liveMetadataDemand(
+	config: ZentuiConfig,
+	owned: { editor: boolean; footer: boolean; workingLine: boolean },
+	piRate = true,
+): LiveMetadataDemand {
+	const references = new Set([
+		...(owned.editor ? editorHostReferences(config) : []),
+		...(owned.footer ? footerHostReferences(config) : []),
+	]);
+	return {
+		github: ["pr_number", "pr_url", "ci"].some((name) => references.has(name)),
+		tokenRate:
+			piRate &&
+			(references.has("token_rate") ||
+				(owned.workingLine &&
+					config.components.workingLine.enabled &&
+					config.components.workingLine.segments.tokenRate === true)),
+	};
+}

package/dist/extensions/pi-zentui/extensions/zentui/live-metadata-display.ts

@@ -0,0 +1,21 @@
+import { componentColor } from "./component-colors";
+import type { ZentuiConfig } from "./config";
+
+/** New roles have no legacy shared-color key; consumers supply their existing safe fallback. */
+export function liveMetadataColor(
+	config: ZentuiConfig,
+	owner: "editor" | "footer",
+	name: string,
+): string | undefined {
+	const role =
+		name === "pr_number"
+			? "prNumber"
+			: name === "pr_url"
+				? "prUrl"
+				: name === "ci"
+					? "ci"
+					: name === "token_rate"
+						? "tokenRate"
+						: undefined;
+	return role ? componentColor(config, owner, role) : undefined;
+}

package/dist/extensions/pi-zentui/extensions/zentui/live-metadata.ts

@@ -0,0 +1,255 @@
+import type { AssistantMessageEvent } from "@earendil-works/pi-ai";
+import { AverageTokenRateTracker, formatAverageTokenRate } from "./average-token-rate";
+import {
+	type GithubContext,
+	type GithubExec,
+	GithubStatusCollector,
+	githubTemplateValues,
+} from "./github-status";
+import { type HostTemplateValues, isHostTemplateVariable } from "./host-template-values";
+import type { MessageEndResult } from "./interaction-summary";
+import type { LiveMetadataDemand } from "./live-metadata-demand";
+import { formatTokenRate, type TokenRateMessage, TokenRateTracker } from "./token-rate";
+
+/** Session resources and demand live outside render; reads are entirely passive. */
+export class LiveMetadataController {
+	readonly rate: TokenRateTracker;
+	private readonly averageRate: AverageTokenRateTracker;
+	private readonly github: GithubStatusCollector;
+	private context: GithubContext | undefined;
+	private demand: LiveMetadataDemand = { github: false, tokenRate: false };
+	private githubTimer: ReturnType<typeof setTimeout> | undefined;
+	private rateTimer: ReturnType<typeof setInterval> | undefined;
+	private streaming = false;
+	private rateLabel = "";
+	/** Bounded provenance: whether the held observation belongs to the latest agent run. */
+	private rateObservedInRun = false;
+	private workingRateLabel = "";
+	private averageLabel = "";
+	private generation = 0;
+	private disposed = false;
+	private scheduledRefresh: number | undefined;
+	constructor(
+		exec: GithubExec,
+		private readonly onRate: (text: string) => void,
+		private readonly repaint: () => void,
+		private readonly reconcileOwnership: () => void,
+		rateNow?: () => number,
+		private readonly githubNow: () => number = Date.now,
+	) {
+		this.rate = new TokenRateTracker(rateNow);
+		this.averageRate = new AverageTokenRateTracker(rateNow);
+		this.github = new GithubStatusCollector(
+			exec,
+			() => {
+				if (!this.disposed && this.context && this.demand.github) this.repaint();
+			},
+			githubNow,
+		);
+	}
+	reconcile(context: GithubContext | undefined, demand: LiveMetadataDemand): void {
+		if (this.disposed) return;
+		const changed =
+			this.context?.cwd !== context?.cwd || this.context?.scopeKey !== context?.scopeKey;
+		const start = demand.github && (!this.demand.github || changed);
+		this.context = context;
+		this.demand = context ? demand : { github: false, tokenRate: false };
+		if (context) this.github.reconcile(context, this.demand.github);
+		else this.github.reconcile({ cwd: "", scopeKey: "" }, false);
+		if (changed || !this.demand.github) {
+			this.generation++;
+			this.stopGithubTimer();
+		}
+		if (start && context) this.scheduleRefresh();
+		if (changed || !this.demand.tokenRate) this.suspendRate(true);
+		this.reconcileRateTimer();
+		this.rateChanged();
+	}
+	startAgent(interactionStarted: boolean): void {
+		if (this.disposed) return;
+		this.rate.agentStart();
+		this.rateObservedInRun = false;
+		if (interactionStarted) this.rateLabel = this.demand.tokenRate ? "— tok/s" : "";
+		this.averageRate.agentStart(interactionStarted);
+		if (this.demand.tokenRate)
+			this.averageLabel = formatAverageTokenRate(this.averageRate.snapshot());
+		else this.averageRate.reset();
+		this.rateChanged();
+	}
+	updateResponse(message: TokenRateMessage, event?: AssistantMessageEvent): void {
+		if (this.disposed || !this.demand.tokenRate) return;
+		this.averageRate.observeTime();
+		if (this.rate.messageUpdate(message, event)) this.rateChanged();
+	}
+	endResponse(
+		message: TokenRateMessage & { stopReason?: unknown },
+		result: MessageEndResult,
+	): void {
+		if (this.disposed || !this.demand.tokenRate || result.status !== "accepted") return;
+		this.rate.messageEnd(message);
+		this.averageRate.messageEnd(message, result);
+		const previous = this.averageLabel;
+		if (this.averageLabel) this.averageLabel = formatAverageTokenRate(this.averageRate.snapshot());
+		this.setStreaming(false);
+		if (previous !== this.averageLabel) this.repaint();
+	}
+	/** Rebaseline live sampling each response, but hold its last observation within an interaction. */
+	startResponse(): void {
+		if (this.disposed) return;
+		this.rate.turnStart();
+		if (!this.rateLabel) this.rateLabel = this.demand.tokenRate ? "— tok/s" : "";
+		if (this.demand.tokenRate) {
+			this.averageRate.turnStart();
+			this.averageLabel = formatAverageTokenRate(this.averageRate.snapshot());
+		} else this.rate.suspend();
+		this.setStreaming(true);
+	}
+	/** Accepted settlement promoted the surviving run into a new interaction. */
+	partitionRates(): void {
+		if (this.disposed) return;
+		const previous = this.averageLabel;
+		this.averageRate.partition();
+		if (this.averageLabel) this.averageLabel = formatAverageTokenRate(this.averageRate.snapshot());
+		if (!this.rateObservedInRun) this.rateLabel = this.demand.tokenRate ? "— tok/s" : "";
+		// Do not suspend the surviving response or its next-turn authorization.
+		this.rateChanged();
+		if (previous !== this.averageLabel) this.repaint();
+	}
+	/** Tools/end retain metadata; identity/boundary changes explicitly clear it. */
+	suspendRate(clearDisplay = false): void {
+		this.rate.suspend();
+		this.averageRate.suspend();
+		const cleared = clearDisplay && (this.rateLabel !== "" || this.averageLabel !== "");
+		const workingWasVisible = this.workingRateLabel !== "";
+		if (clearDisplay) {
+			this.rateObservedInRun = false;
+			this.rateLabel = "";
+			this.averageLabel = "";
+			this.averageRate.reset();
+		} else if (this.averageLabel)
+			this.averageLabel = formatAverageTokenRate(this.averageRate.snapshot());
+		this.setStreaming(false);
+		if (cleared && !workingWasVisible && !this.disposed) this.repaint();
+	}
+	resetRate(): void {
+		this.rate.reset();
+		this.suspendRate(true);
+	}
+	setStreaming(active: boolean): void {
+		this.streaming = !this.disposed && active;
+		this.reconcileRateTimer();
+		this.rateChanged();
+	}
+	rateChanged(): void {
+		if (this.disposed) return;
+		const previous = this.rateLabel;
+		if (this.streaming && this.demand.tokenRate) {
+			// Retain only an observed window rate, never turn final usage into a live sample.
+			const measured = formatTokenRate(this.rate.snapshot());
+			if (measured) {
+				this.rateLabel = measured;
+				// A fresh run may observe the same formatted rate as the preceding run.
+				this.rateObservedInRun = true;
+			}
+		}
+		// WorkingLineController owns row visibility; tools/gaps retain historical observation only.
+		const workingText = this.demand.tokenRate ? this.rateLabel : "";
+		const workingChanged = workingText !== this.workingRateLabel;
+		if (workingChanged) {
+			this.workingRateLabel = workingText;
+			this.onRate(workingText);
+		}
+		if (previous !== this.rateLabel || workingChanged) this.repaint();
+	}
+	invalidateProject(): void {
+		if (this.disposed || !this.demand.github) return;
+		this.generation++;
+		this.stopGithubTimer();
+		this.github.invalidate();
+		this.scheduleRefresh();
+	}
+	private scheduleRefresh(): void {
+		if (!this.demand.github || this.disposed || this.scheduledRefresh === this.generation) return;
+		const generation = this.generation;
+		this.scheduledRefresh = generation;
+		// Branch invalidation can originate in render; never execute there.
+		queueMicrotask(() => {
+			if (this.scheduledRefresh === generation) this.scheduledRefresh = undefined;
+			if (generation !== this.generation || !this.demand.github || this.disposed) return;
+			this.stopGithubTimer();
+			const completed = () => {
+				if (generation === this.generation && this.demand.github && !this.disposed)
+					this.scheduleNextGithubRefresh();
+			};
+			void this.github.refresh().then(completed, completed);
+		});
+	}
+	private scheduleNextGithubRefresh(): void {
+		this.stopGithubTimer();
+		const expiresAt = this.github.snapshot()?.expiresAt;
+		const remaining = expiresAt === undefined ? Number.NaN : expiresAt - this.githubNow();
+		// Identity failures have no cache deadline; retry on the base cadence. Never spin at zero.
+		const delay = Number.isFinite(remaining) ? Math.max(1, Math.min(30_000, remaining)) : 30_000;
+		const generation = this.generation;
+		const timer = setTimeout(() => {
+			if (
+				this.githubTimer !== timer ||
+				generation !== this.generation ||
+				!this.demand.github ||
+				this.disposed
+			)
+				return;
+			this.githubTimer = undefined;
+			this.reconcileOwnership();
+			if (generation !== this.generation || !this.demand.github || this.disposed) return;
+			// snapshot() marks expired CI stale. Repaint before the deferred refresh can wait on I/O.
+			this.repaint();
+			this.scheduleRefresh();
+		}, delay);
+		this.githubTimer = timer;
+		timer.unref?.();
+	}
+	read(names: ReadonlySet<string>, native?: HostTemplateValues): HostTemplateValues {
+		const values: Partial<Record<keyof HostTemplateValues, string>> = { ...native };
+		// The shared passive snapshot replaces only the PR/CI path, never OMP rate/quota/modes.
+		delete values.pr_number;
+		delete values.pr_url;
+		delete values.ci;
+		Object.assign(values, githubTemplateValues(this.github.snapshot()));
+		if (!native && this.demand.tokenRate && this.averageLabel)
+			values.token_rate = this.averageLabel;
+		return Object.fromEntries(
+			Object.entries(values).filter(([name]) => names.has(name) && isHostTemplateVariable(name)),
+		);
+	}
+	reset(): void {
+		this.generation++;
+		this.context = undefined;
+		this.demand = { github: false, tokenRate: false };
+		this.github.reconcile({ cwd: "", scopeKey: "" }, false);
+		this.stopGithubTimer();
+		this.resetRate();
+	}
+	dispose(): void {
+		this.disposed = true;
+		this.reset();
+		this.github.dispose();
+	}
+	private stopGithubTimer(): void {
+		if (this.githubTimer) clearTimeout(this.githubTimer);
+		this.githubTimer = undefined;
+	}
+	private reconcileRateTimer(): void {
+		if (!(this.streaming && this.demand.tokenRate)) {
+			if (this.rateTimer) clearInterval(this.rateTimer);
+			this.rateTimer = undefined;
+			return;
+		}
+		if (this.rateTimer) return;
+		this.rateTimer = setInterval(() => {
+			this.reconcileOwnership();
+			this.rateChanged();
+		}, 250);
+		this.rateTimer.unref?.();
+	}
+}