@selesai/code 0.10.1 → 0.11.0

package/dist/extensions/pi-tool-display/tool-display-api-consumer.d.ts

@@ -0,0 +1,30 @@
+export type RuntimeToolDefinition = Record<string, unknown>;
+
+export interface ToolDisplayAdapter {
+  kind?: "read" | "edit" | "mcp" | "generic";
+  overrideExistingRenderers?: boolean;
+}
+
+export interface ToolDisplayApi {
+  version: 1;
+  decorateTool<T extends RuntimeToolDefinition>(tool: T, adapter?: ToolDisplayAdapter | Record<string, unknown>): T;
+}
+
+export interface DecorateToolForDisplayOptions {
+  suppressDecorateErrors?: boolean;
+}
+
+export declare function getToolDisplayApi(): ToolDisplayApi | undefined;
+
+export declare function queueToolDisplayDecoration<T extends RuntimeToolDefinition>(
+  tool: T,
+  adapter?: ToolDisplayAdapter | Record<string, unknown>,
+): void;
+
+export declare function decorateToolForDisplay<T extends object>(
+  tool: T,
+  adapter?: ToolDisplayAdapter | Record<string, unknown>,
+  options?: DecorateToolForDisplayOptions,
+): T;
+
+export declare function decorateMcpToolForDisplay<T extends RuntimeToolDefinition>(tool: T): T;

package/dist/extensions/pi-tool-display/tool-display-api-consumer.js

@@ -0,0 +1,40 @@
+const TOOL_DISPLAY_API_KEY = Symbol.for("pi-tool-display.api.v1");
+const TOOL_DISPLAY_PENDING_DECORATIONS_KEY = Symbol.for("pi-tool-display.pendingDecorations.v1");
+
+export function getToolDisplayApi() {
+  const api = globalThis[TOOL_DISPLAY_API_KEY];
+  if (api?.version !== 1 || typeof api.decorateTool !== "function") {
+    return undefined;
+  }
+
+  return api;
+}
+
+export function queueToolDisplayDecoration(tool, adapter) {
+  const existing = globalThis[TOOL_DISPLAY_PENDING_DECORATIONS_KEY];
+  const queue = Array.isArray(existing) ? existing : [];
+  queue.push({ tool, adapter });
+  globalThis[TOOL_DISPLAY_PENDING_DECORATIONS_KEY] = queue;
+}
+
+export function decorateToolForDisplay(tool, adapter, options = {}) {
+  const api = getToolDisplayApi();
+  if (!api) {
+    queueToolDisplayDecoration(tool, adapter);
+    return tool;
+  }
+
+  try {
+    return api.decorateTool(tool, adapter);
+  } catch (error) {
+    if (options.suppressDecorateErrors) {
+      return tool;
+    }
+
+    throw error;
+  }
+}
+
+export function decorateMcpToolForDisplay(tool) {
+  return decorateToolForDisplay(tool, { kind: "mcp", overrideExistingRenderers: true });
+}

package/dist/extensions/pi-zentui/extensions/zentui/format.ts

@@ -93,9 +93,13 @@ type SessionEntry = {
 	id?: string | number;
 	timestamp?: string | number;
 	usage?: SessionUsage;
+	customType?: string;
+	data?: unknown;
 	message?: {
 		role?: string;
 		usage?: SessionUsage;
+		provider?: string;
+		responseId?: string;
 	};
 };
 
@@ -105,6 +109,16 @@ type SelectedUsage = {
 	isAssistant: boolean;
 };
 
+/** A cost-reconcile entry written by the cost-reconcile extension. */
+export type CostReconcileData = {
+	version?: number;
+	provider?: string;
+	model?: string;
+	responseId?: string;
+	cost?: number;
+	reconciledAt?: number;
+};
+
 type UsageCacheEntry = {
 	key: string;
 	totals: UsageTotals;
@@ -206,6 +220,15 @@ function normalizedUsage(usage: SessionUsage | undefined) {
 }
 
 function entryIdentity(entry: SessionEntry): string {
+	if (entry.type === "custom") {
+		return JSON.stringify([
+			entry.id ?? null,
+			entry.timestamp ?? null,
+			entry.type ?? null,
+			entry.customType ?? null,
+			entry.data ?? null,
+		]);
+	}
 	const selected = usageForEntry(entry);
 	if (!selected) return "unsupported";
 	const usage = normalizedUsage(selected.usage);
@@ -214,6 +237,7 @@ function entryIdentity(entry: SessionEntry): string {
 		entry.timestamp ?? null,
 		entry.type ?? null,
 		entry.message?.role ?? null,
+		entry.customType ?? null,
 		selected.location,
 		usage.input,
 		usage.output,
@@ -236,6 +260,19 @@ function computeUsageTotals(entries: readonly SessionEntry[]): UsageTotals {
 	let latestCacheHitRate: number | undefined;
 	let cost = 0;
 
+	// Costs reconciled from the gateway (authoritative billed amounts) keyed by
+	// `provider:responseId`. When present they replace the rate-card estimate
+	// for that response.
+	const reconciledCosts = new Map<string, number>();
+	for (const entry of entries) {
+		if (entry.type !== "custom" || entry.customType !== "cost-reconcile") continue;
+		const data = entry.data as CostReconcileData | undefined;
+		if (!data || typeof data !== "object") continue;
+		if (typeof data.provider !== "string" || typeof data.responseId !== "string") continue;
+		if (typeof data.cost !== "number" || !Number.isFinite(data.cost) || data.cost < 0) continue;
+		reconciledCosts.set(`${data.provider}:${data.responseId}`, data.cost);
+	}
+
 	for (const entry of entries) {
 		const selected = usageForEntry(entry);
 		if (!selected) continue;
@@ -245,7 +282,15 @@ function computeUsageTotals(entries: readonly SessionEntry[]): UsageTotals {
 		output = addUsageTotal(output, usage.output);
 		cacheRead = addUsageTotal(cacheRead, usage.cacheRead);
 		cacheWrite = addUsageTotal(cacheWrite, usage.cacheWrite);
-		cost = addUsageTotal(cost, usage.cost);
+		const entryCost = usage.cost;
+		let effectiveCost = entryCost;
+		const provider = entry.message?.provider;
+		const responseId = entry.message?.responseId;
+		if (provider && responseId) {
+			const reconciled = reconciledCosts.get(`${provider}:${responseId}`);
+			if (reconciled !== undefined) effectiveCost = reconciled;
+		}
+		cost = addUsageTotal(cost, effectiveCost);
 		if (selected.isAssistant) {
 			latestCacheHitRate = calculateCacheHitRate(usage.input, usage.cacheRead, usage.cacheWrite);
 		}

package/dist/extensions/pi-zentui/extensions/zentui/index.ts

@@ -1385,6 +1385,16 @@ export default function (pi: ExtensionAPI) {
 				// A transcript persistence failure must not break settlement cleanup.
 			}
 		}
+		// Gateway cost reconciliation lands a few seconds after settle; refresh
+		// once late so the cost label picks up authoritative totals when they
+		// arrive. Best-effort: harmless in non-TUI contexts.
+		sessionLifecycle.defer(
+			() => {
+				invalidateUsageTotalsCache();
+				refreshInteractiveState(ctx);
+			},
+			12_000,
+		);
 	});
 	pi.on("tool_execution_start", (event, ctx) => {
 		liveContext.clear();

package/dist/extensions/pi-zentui/extensions/zentui/user-message-styles.ts

@@ -45,7 +45,7 @@ function makeMarkdownTheme(theme: Theme | undefined): MarkdownTheme {
 
 function renderMarkdown(text: string, width: number, theme: Theme | undefined): string[] {
 	const renderer = new Markdown(text, 0, 0, makeMarkdownTheme(theme), {
-		color: (content) => themeFg(theme, "userMessageText", content),
+		color: (content) => themeFg(theme, "accent", content),
 	});
 	const lines = renderer.render(Math.max(1, width));
 	return lines.length > 0 ? lines : [""];

package/dist/extensions/pi-zentui/test/extension-compliance.test.ts

@@ -2157,7 +2157,7 @@ describe("Pi docs compliance", () => {
 		const raw = new UserMessageComponent("hello").render(80).join("\n");
 		expect(raw).toMatch(/\[accent\]│|\u001b\[34m│\u001b\[0m/);
 		expect(raw).toMatch(/\[borderMuted\]────|\u001b\[90m────/);
-		expect(rendered).toContain("[userMessageText]");
+		expect(rendered).toContain("[accent]");
 		expect(rendered).toContain("[bold]");
 		expect(rendered).not.toContain("**zentui**");
 		expect(rendered).not.toContain("claude-sonnet");
@@ -2296,8 +2296,8 @@ describe("Pi docs compliance", () => {
 
 		expect(cachedRender).toBe(firstRender);
 		expect(invalidate).toHaveBeenCalledTimes(1);
-		expect(invalidatedRender).toContain("[second:userMessageText]hello");
-		expect(invalidatedRender).not.toContain("[first:userMessageText]hello");
+		expect(invalidatedRender).toContain("[second:accent]hello");
+		expect(invalidatedRender).not.toContain("[first:accent]hello");
 	});
 
 	it("renders selector borders from their independent canonical color source", () => {

package/dist/extensions/pi-zentui/test/format.test.ts

@@ -58,8 +58,17 @@ function makeAssistantEntry(
 	return makeMessageUsageEntry("assistant", makeUsage(input, output, cost, cacheRead, cacheWrite));
 }
 
-function makeMessageUsageEntry(role: string, usage: TestUsage | undefined) {
-	return { type: "message", message: { role, usage } };
+function makeMessageUsageEntry(role: string, usage: TestUsage | undefined, extra: Record<string, unknown> = {}) {
+	return { type: "message", message: { role, usage, ...extra } };
+}
+
+function makeReconcileEntry(provider: string, responseId: string, cost: number) {
+	return {
+		type: "custom",
+		customType: "cost-reconcile",
+		id: `reconcile-${provider}-${responseId}`,
+		data: { version: 1, provider, model: "test-model", responseId, cost, reconciledAt: 0 },
+	};
 }
 
 function makeSummaryUsageEntry(
@@ -114,6 +123,45 @@ describe("usage formatting", () => {
 		expect(buildCostLabel(totals)).toBe("$26.000");
 	});
 
+	it("prefers reconciled gateway cost over the rate-card estimate", () => {
+		const assistant = makeMessageUsageEntry("assistant", makeUsage(1_000, 500, 0.42), {
+			provider: "openrouter",
+			responseId: "gen-abc123",
+		});
+		const reconcile = makeReconcileEntry("openrouter", "gen-abc123", 0.0123);
+		const ctx = makeSessionContext([assistant, reconcile]);
+
+		const totals = getUsageTotals(ctx as never);
+
+		expect(totals.cost).toBe(0.0123);
+		expect(buildCostLabel(totals)).toBe("$0.012");
+	});
+
+	it("keeps the rate-card estimate when no reconcile entry exists", () => {
+		const assistant = makeMessageUsageEntry("assistant", makeUsage(1_000, 500, 0.42), {
+			provider: "openrouter",
+			responseId: "gen-abc123",
+		});
+		const ctx = makeSessionContext([assistant]);
+
+		const totals = getUsageTotals(ctx as never);
+
+		expect(totals.cost).toBe(0.42);
+	});
+
+	it("reconcile entries do not double-count when the estimate is zero", () => {
+		const assistant = makeMessageUsageEntry("assistant", makeUsage(1_000, 500, 0), {
+			provider: "openrouter",
+			responseId: "gen-abc123",
+		});
+		const reconcile = makeReconcileEntry("openrouter", "gen-abc123", 0.0123);
+		const ctx = makeSessionContext([assistant, reconcile]);
+
+		const totals = getUsageTotals(ctx as never);
+
+		expect(totals.cost).toBe(0.0123);
+	});
+
 	it("formats cache atoms independently and omits zero totals", () => {
 		expect(buildCacheReadLabel(1_200)).toBe("R1.2k");
 		expect(buildCacheWriteLabel(300)).toBe("W300");

package/dist/modes/interactive/components/startup-box.d.ts

@@ -0,0 +1,38 @@
+import type { Component } from "@earendil-works/pi-tui";
+/**
+ * Pure layout math for the startup resource boxes. No coloring here so it can
+ * be unit-tested without a terminal.
+ *
+ * Items flow horizontally into columns; the box width hugs its content and
+ * never exceeds maxWidth:
+ *
+ *   ╭─ Skills ────────────────────────╮
+ *   │ • alpha    • gamma    • zeta    │
+ *   │ • beta     • delta              │
+ *   ╰─────────────────────────────────╯
+ *
+ * Every line is exactly `innerWidth + 2` visible characters: outer border char
+ * (1) + inner content (innerWidth) + border char (1).
+ */
+/** Minimum inner width so the bullet, label, and padding always have room. */
+export declare const MIN_BOX_INNER_WIDTH = 6;
+/** Visible line width for a box with the given inner content width. */
+export declare function boxLineWidth(innerWidth: number): number;
+/**
+ * Build the box lines for a titled bullet box.
+ * Labels are trimmed and sorted. Items flow into as many columns as fit within
+ * `maxWidth`; the box shrinks to its content (never wider than maxWidth).
+ * Anything that still doesn't fit is ellipsis-truncated.
+ */
+export declare function buildBulletBoxLines(title: string, items: string[], maxWidth?: number): string[];
+/**
+ * Responsive boxed bullet list component. Recomputes layout per render width,
+ * so it stays correct on terminal resize.
+ */
+export declare class StartupBox implements Component {
+    private readonly title;
+    private readonly items;
+    constructor(title: string, items: string[]);
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/modes/interactive/components/startup-box.js

@@ -0,0 +1,90 @@
+import { theme } from "../theme/theme.js";
+/**
+ * Pure layout math for the startup resource boxes. No coloring here so it can
+ * be unit-tested without a terminal.
+ *
+ * Items flow horizontally into columns; the box width hugs its content and
+ * never exceeds maxWidth:
+ *
+ *   ╭─ Skills ────────────────────────╮
+ *   │ • alpha    • gamma    • zeta    │
+ *   │ • beta     • delta              │
+ *   ╰─────────────────────────────────╯
+ *
+ * Every line is exactly `innerWidth + 2` visible characters: outer border char
+ * (1) + inner content (innerWidth) + border char (1).
+ */
+/** Minimum inner width so the bullet, label, and padding always have room. */
+export const MIN_BOX_INNER_WIDTH = 6;
+/** Visible line width for a box with the given inner content width. */
+export function boxLineWidth(innerWidth) {
+    return innerWidth + 2;
+}
+/**
+ * Build the box lines for a titled bullet box.
+ * Labels are trimmed and sorted. Items flow into as many columns as fit within
+ * `maxWidth`; the box shrinks to its content (never wider than maxWidth).
+ * Anything that still doesn't fit is ellipsis-truncated.
+ */
+export function buildBulletBoxLines(title, items, maxWidth) {
+    const labels = items
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0)
+        .sort((a, b) => a.localeCompare(b));
+    const longestLabel = labels.reduce((max, label) => Math.max(max, label.length), 0);
+    const gap = 2;
+    const naturalCell = longestLabel + 2; // "• label" + one pad
+    const titleWidth = Math.max(title.length + 4, MIN_BOX_INNER_WIDTH);
+    const maxInner = maxWidth !== undefined ? Math.max(1, maxWidth - 2) : Infinity;
+    // Cell width and column count: fit as many columns as the budget allows.
+    const cellWidth = Math.min(naturalCell, maxInner);
+    const maxCols = maxWidth !== undefined
+        ? Math.max(1, Math.floor((maxInner + gap) / (cellWidth + gap)))
+        : Math.max(1, labels.length);
+    const cols = Math.min(labels.length, maxCols);
+    // Box hugs content: columns + gaps, at least as wide as the title, capped by budget.
+    const contentWidth = cols * cellWidth + gap * (cols - 1);
+    const innerWidth = Math.min(Math.max(titleWidth, contentWidth), maxInner);
+    const fit = (label) => label.length <= cellWidth - 2 ? label : `${label.slice(0, cellWidth - 3)}…`;
+    const rows = Math.ceil(labels.length / cols);
+    const topInner = `─ ${title} ${"─".repeat(Math.max(0, innerWidth - title.length - 3))}`.slice(0, innerWidth);
+    const top = `╭${topInner}╮`;
+    const bottom = `╰${"─".repeat(innerWidth)}╯`;
+    const rowLines = Array.from({ length: rows }, (_, row) => {
+        const cells = [];
+        for (let col = 0; col < cols; col++) {
+            const label = labels[row * cols + col];
+            cells.push(label === undefined ? " ".repeat(cellWidth) : `• ${fit(label)}`.padEnd(cellWidth));
+        }
+        const content = cells.join(" ".repeat(gap));
+        return `│${content.padEnd(innerWidth)}│`;
+    });
+    return [top, ...rowLines, bottom];
+}
+/**
+ * Responsive boxed bullet list component. Recomputes layout per render width,
+ * so it stays correct on terminal resize.
+ */
+export class StartupBox {
+    title;
+    items;
+    constructor(title, items) {
+        this.title = title;
+        this.items = items;
+    }
+    invalidate() {
+        // Stateless per render; nothing cached.
+    }
+    render(width) {
+        const lines = buildBulletBoxLines(this.title, this.items, width);
+        const border = (s) => theme.fg("border", s);
+        return lines.map((line, index) => {
+            // Top line: color the embedded title with the heading color.
+            const match = index === 0 ? line.match(/^(╭─ )(.+?)( ─*╮)$/) : undefined;
+            if (match) {
+                return border(match[1]) + theme.fg("mdHeading", match[2]) + border(match[3]);
+            }
+            return border(line);
+        });
+    }
+}

package/dist/modes/interactive/interactive-mode.d.ts

@@ -118,6 +118,7 @@ export declare class InteractiveMode {
     private customFooter;
     private headerContainer;
     private builtInHeader;
+    private startupBannerDismissed;
     private customHeader;
     private options;
     private readonly onRightClickPaste;
@@ -179,6 +180,8 @@ export declare class InteractiveMode {
     private formatPathWithSource;
     private formatDiagnostics;
     private showLoadedResources;
+    /** Dismiss the startup banner (logo + loaded resources) on first user message. */
+    private dismissStartupBanner;
     private bindCurrentSessionExtensions;
     private applyRuntimeSettings;
     private rebindCurrentSession;