@danypops/pi-jittor 0.2.0 → 0.3.0

package/extension/src/settings-tui.ts

@@ -1,6 +1,7 @@
+import { USAGE_PERIODS, type UsagePeriod } from "@danypops/jittor";
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { USAGE_PERIODS, type UsagePeriod } from "@danypops/jittor";
+import { BorderedSelectPanel, Menu, type MenuTheme, type TextMeasure } from "malevich-tui-components";
 import type { CodexRecoveryControl, EnforcementControl, UsageBudgetControl } from "./settings.ts";
 
 export interface SettingsSnapshot {
@@ -24,12 +25,7 @@ export interface SettingsEffects {
 	setRecovery(enabled: boolean): void | Promise<void>;
 }
 
-const SETTINGS_KEYS: SettingsKey[] = [
-	"enforcement",
-	"footer",
-	"recovery",
-	...USAGE_PERIODS.map(({ id }) => `budget-${id}` as const),
-];
+const SETTINGS_KEYS: SettingsKey[] = ["enforcement", "footer", "recovery", ...USAGE_PERIODS.map(({ id }) => `budget-${id}` as const)];
 
 function state(enabled: boolean, theme: SettingsTheme): string {
 	return enabled ? theme.fg("success", "ON") : theme.fg("muted", "OFF");
@@ -61,20 +57,53 @@ export function settingsSnapshot(
 	};
 }
 
+const hostTextMeasure: TextMeasure = { visibleWidth, truncateToWidth };
+
+function menuTheme(theme: SettingsTheme): MenuTheme {
+	return {
+		border: () => "",
+		selected: (text) => theme.fg("accent", text),
+		normal: (text) => text,
+		dim: (text) => theme.fg("dim", text),
+		title: theme.bold,
+	};
+}
+
+function createSettingsPanel(
+	snapshot: SettingsSnapshot,
+	theme: SettingsTheme,
+	onAction: (action: SettingsAction) => void,
+	selected = 0,
+): BorderedSelectPanel {
+	const menu = new Menu({
+		items: SETTINGS_KEYS.map((key) => ({ label: rowText(key, snapshot, theme), action: () => onAction({ kind: "activate", key }) })),
+		theme: menuTheme(theme),
+		onClose: () => onAction({ kind: "close" }),
+		measure: hostTextMeasure,
+		matchesKey: (data, key) => {
+			if (key === "enter") return matchesKey(data, "enter") || matchesKey(data, "space");
+			if (key === "escape") return matchesKey(data, "escape") || matchesKey(data, "ctrl+c");
+			if (key === "up") return matchesKey(data, "up");
+			if (key === "down") return matchesKey(data, "down");
+			return false;
+		},
+	});
+	for (let index = 0; index < selected; index += 1) menu.handleInput("\x1b[B");
+	return new BorderedSelectPanel({
+		title: "Jittor Settings",
+		list: menu,
+		helpText: "Token budgets are user values; provider quotas remain separate. · ↑/↓ select · Enter edit · Esc close",
+		theme: {
+			border: (text) => theme.fg("borderMuted", text),
+			title: theme.bold,
+			help: (text) => theme.fg("dim", text),
+		},
+		measure: hostTextMeasure,
+	});
+}
+
 export function renderSettingsView(snapshot: SettingsSnapshot, selected: number, width: number, theme: SettingsTheme): string[] {
-	const safeWidth = Math.max(20, width);
-	const lines = [
-		theme.bold("Jittor Settings"),
-		theme.fg("dim", "Token budgets are user values; provider quotas remain separate."),
-		"",
-	];
-	for (let index = 0; index < SETTINGS_KEYS.length; index += 1) {
-		const selectedRow = index === selected;
-		const prefix = selectedRow ? theme.fg("accent", "› ") : "  ";
-		lines.push(`${prefix}${rowText(SETTINGS_KEYS[index]!, snapshot, theme)}`);
-	}
-	lines.push("", theme.fg("dim", "↑/↓ select · Enter edit · Esc close"));
-	return lines.map((line) => visibleWidth(line) <= safeWidth ? line : truncateToWidth(line, safeWidth, "…"));
+	return createSettingsPanel(snapshot, theme, () => undefined, Math.max(0, selected)).render(Math.max(20, width));
 }
 
 function plainTheme(): SettingsTheme {
@@ -88,7 +117,7 @@ async function editBudget(ctx: ExtensionCommandContext, budgets: UsageBudgetCont
 	if (input === undefined) return;
 	const normalized = input.trim().toLowerCase();
 	if (normalized === "off" || normalized === "clear") {
-		budgets.setUsageTokenBudget(period, undefined);
+		await budgets.setUsageTokenBudget(period, undefined);
 		ctx.ui.notify(`${label} token budget cleared.`, "info");
 		return;
 	}
@@ -97,7 +126,7 @@ async function editBudget(ctx: ExtensionCommandContext, budgets: UsageBudgetCont
 		ctx.ui.notify("Enter a positive token count, or `off` to clear this threshold.", "warning");
 		return;
 	}
-	budgets.setUsageTokenBudget(period, tokens);
+	await budgets.setUsageTokenBudget(period, tokens);
 	ctx.ui.notify(`${label} token budget set to ${tokens.toLocaleString()} tokens.`, "info");
 }
 
@@ -113,28 +142,33 @@ export async function showSettingsPanel(
 	},
 ): Promise<void> {
 	if (ctx.mode !== "tui") {
-		ctx.ui.notify(renderSettingsView(settingsSnapshot(enforcement, recovery, budgets), -1, 100, plainTheme()).slice(0, -2).join("\n"), "info");
+		const snapshot = settingsSnapshot(enforcement, recovery, budgets);
+		ctx.ui.notify(["Jittor Settings", ...SETTINGS_KEYS.map((key) => rowText(key, snapshot, plainTheme()))].join("\n"), "info");
 		return;
 	}
 	for (;;) {
 		const snapshot = settingsSnapshot(enforcement, recovery, budgets);
 		const action = await ctx.ui.custom<SettingsAction>((tui, theme, _keybindings, done) => {
-			let selected = 0;
+			const panel = createSettingsPanel(snapshot, theme, done);
 			return {
-				invalidate() {},
-				render(width: number): string[] { return renderSettingsView(snapshot, selected, width, theme); },
-				handleInput(data: string): void {
-					if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || data === "q") done({ kind: "close" });
-					else if (matchesKey(data, "up")) { selected = (selected - 1 + SETTINGS_KEYS.length) % SETTINGS_KEYS.length; tui.requestRender(); }
-					else if (matchesKey(data, "down")) { selected = (selected + 1) % SETTINGS_KEYS.length; tui.requestRender(); }
-					else if (matchesKey(data, "return") || matchesKey(data, "enter") || matchesKey(data, "space")) done({ kind: "activate", key: SETTINGS_KEYS[selected]! });
+				invalidate: () => panel.invalidate(),
+				render: (width) => panel.render(width),
+				handleInput(data: string) {
+					panel.handleInput(data);
+					tui.requestRender();
 				},
 			};
 		});
 		if (!action || action.kind === "close") return;
 		if (action.key === "enforcement") {
 			if (enforcement.isEnabled()) {
-				if (await ctx.ui.confirm("Disable routing enforcement?", "Jittor will remain monitor-only and will no longer block unsafe provider requests.")) await effects.setEnforcement(false);
+				if (
+					await ctx.ui.confirm(
+						"Disable routing enforcement?",
+						"Jittor will remain monitor-only and will no longer block unsafe provider requests.",
+					)
+				)
+					await effects.setEnforcement(false);
 			} else await effects.setEnforcement(true);
 			continue;
 		}
@@ -144,7 +178,13 @@ export async function showSettingsPanel(
 		}
 		if (action.key === "recovery") {
 			if (!recovery.isCodexRecoveryEnabled()) {
-				if (await ctx.ui.confirm("Enable Codex recovery?", "Jittor may start bounded hidden retries only after transient Codex failures fully settle.")) await effects.setRecovery(true);
+				if (
+					await ctx.ui.confirm(
+						"Enable Codex recovery?",
+						"Jittor may start bounded hidden retries only after transient Codex failures fully settle.",
+					)
+				)
+					await effects.setRecovery(true);
 			} else await effects.setRecovery(false);
 			continue;
 		}

package/extension/src/settings.ts

@@ -1,22 +1,33 @@
-import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { JITTOR_EXTENSION_SETTINGS_FILENAME, JITTOR_STATE_DIRECTORY, USAGE_PERIODS, type UsagePeriod } from "@danypops/jittor";
+import { createAtomicJsonWriter } from "@danypops/vehicle-core";
+import { createNodeAtomicJsonFsAdapter } from "@danypops/vehicle-server/atomic-json";
 
+const atomicJson = createAtomicJsonWriter({ fs: createNodeAtomicJsonFsAdapter() });
+
+// Every setter persists to disk before resolving, so a caller that awaits it (every real call
+// site in index.ts/settings-tui.ts already runs inside an async handler) observes a completed
+// write -- no fire-and-forget persistence that a subsequent synchronous re-read could race. The
+// return type stays `void | Promise<void>` (not a strict `Promise<void>`) so a test/adapter
+// implementation that has no real persistence to await (e.g. the no-op fallback stubs in
+// index.ts's usageBudgetControl()/recoveryControl()) can stay trivially synchronous.
 export interface EnforcementControl {
 	isEnabled(): boolean;
-	setEnabled(enabled: boolean): void;
+	setEnabled(enabled: boolean): void | Promise<void>;
 	isFooterEnabled(): boolean;
-	setFooterEnabled(enabled: boolean): void;
+	setFooterEnabled(enabled: boolean): void | Promise<void>;
 }
 
 export interface CodexRecoveryControl {
 	isCodexRecoveryEnabled(): boolean;
-	setCodexRecoveryEnabled(enabled: boolean): void;
+	setCodexRecoveryEnabled(enabled: boolean): void | Promise<void>;
 }
 
 export interface UsageBudgetControl {
 	getUsageTokenBudget(period: UsagePeriod): number | undefined;
-	setUsageTokenBudget(period: UsagePeriod, tokens: number | undefined): void;
+	setUsageTokenBudget(period: UsagePeriod, tokens: number | undefined): void | Promise<void>;
 }
 
 export interface PersistentExtensionControl extends EnforcementControl, CodexRecoveryControl, UsageBudgetControl {}
@@ -35,14 +46,16 @@ function defaultSettings(): ExtensionSettings {
 function parseUsageTokenBudgets(value: unknown): Partial<Record<UsagePeriod, number>> {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
 	const record = value as Record<string, unknown>;
-	return Object.fromEntries(USAGE_PERIODS.flatMap(({ id }) => {
-		const tokens = record[id];
-		return typeof tokens === "number" && Number.isFinite(tokens) && tokens > 0 ? [[id, tokens]] : [];
-	})) as Partial<Record<UsagePeriod, number>>;
+	return Object.fromEntries(
+		USAGE_PERIODS.flatMap(({ id }) => {
+			const tokens = record[id];
+			return typeof tokens === "number" && Number.isFinite(tokens) && tokens > 0 ? [[id, tokens]] : [];
+		}),
+	) as Partial<Record<UsagePeriod, number>>;
 }
 
 function settingsPath(env: Record<string, string | undefined> = process.env): string {
-	const config = env["XDG_CONFIG_HOME"] ?? join(env["HOME"] ?? ".", ".config");
+	const config = env.XDG_CONFIG_HOME ?? join(env.HOME ?? ".", ".config");
 	return join(config, JITTOR_STATE_DIRECTORY, JITTOR_EXTENSION_SETTINGS_FILENAME);
 }
 
@@ -52,22 +65,19 @@ function loadSettings(path: string): ExtensionSettings {
 		if (typeof value !== "object" || value === null || Array.isArray(value)) return defaultSettings();
 		const record = value as Record<string, unknown>;
 		return {
-			enforcementEnabled: record["enforcementEnabled"] !== false,
-			footerEnabled: record["footerEnabled"] !== false,
-			codexRecoveryEnabled: record["codexRecoveryEnabled"] === true,
-			usageTokenBudgets: parseUsageTokenBudgets(record["usageTokenBudgets"]),
+			enforcementEnabled: record.enforcementEnabled !== false,
+			footerEnabled: record.footerEnabled !== false,
+			codexRecoveryEnabled: record.codexRecoveryEnabled === true,
+			usageTokenBudgets: parseUsageTokenBudgets(record.usageTokenBudgets),
 		};
 	} catch {
 		return defaultSettings();
 	}
 }
 
-function persistSettings(path: string, settings: ExtensionSettings): void {
-	mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-	const temporary = `${path}.${process.pid}.tmp`;
-	writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600 });
-	chmodSync(temporary, 0o600);
-	renameSync(temporary, path);
+async function persistSettings(path: string, settings: ExtensionSettings): Promise<void> {
+	await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+	await atomicJson.write(path, settings, { mode: 0o600, pretty: true, trailingNewline: true });
 }
 
 export function persistentEnforcementControl(env: Record<string, string | undefined> = process.env): PersistentExtensionControl {
@@ -75,28 +85,29 @@ export function persistentEnforcementControl(env: Record<string, string | undefi
 	const settings = loadSettings(path);
 	return {
 		isEnabled: () => settings.enforcementEnabled,
-		setEnabled(value: boolean): void {
+		async setEnabled(value: boolean): Promise<void> {
 			settings.enforcementEnabled = value;
-			persistSettings(path, settings);
+			await persistSettings(path, settings);
 		},
 		isFooterEnabled: () => settings.footerEnabled,
-		setFooterEnabled(value: boolean): void {
+		async setFooterEnabled(value: boolean): Promise<void> {
 			settings.footerEnabled = value;
-			persistSettings(path, settings);
+			await persistSettings(path, settings);
 		},
 		isCodexRecoveryEnabled: () => settings.codexRecoveryEnabled,
-		setCodexRecoveryEnabled(value: boolean): void {
+		async setCodexRecoveryEnabled(value: boolean): Promise<void> {
 			settings.codexRecoveryEnabled = value;
-			persistSettings(path, settings);
+			await persistSettings(path, settings);
 		},
 		getUsageTokenBudget(period): number | undefined {
 			return settings.usageTokenBudgets[period];
 		},
-		setUsageTokenBudget(period, tokens): void {
-			if (tokens !== undefined && (!Number.isFinite(tokens) || tokens <= 0)) throw new Error("usage token budget must be a positive finite number");
+		async setUsageTokenBudget(period, tokens): Promise<void> {
+			if (tokens !== undefined && (!Number.isFinite(tokens) || tokens <= 0))
+				throw new Error("usage token budget must be a positive finite number");
 			if (tokens === undefined) delete settings.usageTokenBudgets[period];
 			else settings.usageTokenBudgets[period] = tokens;
-			persistSettings(path, settings);
+			await persistSettings(path, settings);
 		},
 	};
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danypops/pi-jittor",
-  "version": "0.2.0",
-  "description": "Pi extension for Jittor: native routing enforcement, footer, settings, usage graphs, and benchmark panels backed by the @danypops/jittor daemon",
+  "version": "0.3.0",
+  "description": "Pi extension for Jittor token and context observability with optimization controls backed by the @danypops/jittor daemon",
   "type": "module",
   "keywords": ["pi-package", "llm-router", "token-budget"],
   "scripts": {
@@ -12,9 +12,11 @@
     "extensions": ["extension/src/index.ts"]
   },
   "dependencies": {
-    "@danypops/vehicle-client": "^0.1.1",
-    "@danypops/jittor": "^0.14.0",
-    "malevich-tui-components": "^0.6.0"
+    "@danypops/vehicle-client": "^0.5.1",
+    "@danypops/vehicle-core": "^0.12.1",
+    "@danypops/vehicle-server": "^0.17.0",
+    "@danypops/jittor": "workspace:^",
+    "malevich-tui-components": "^0.16.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
@@ -22,6 +24,10 @@
     "typebox": "*"
   },
   "devDependencies": {
+    "@danypops/pi-extension-harness": "^0.6.2",
+    "@danypops/pi-process-harness": "^0.1.2",
+    "@danypops/pi-tui-harness": "^0.0.2",
+    "@earendil-works/pi-ai": "*",
     "bun-types": "latest"
   },
   "repository": {

package/extension/src/benchmark-tui.ts

@@ -1,113 +0,0 @@
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
-import {
-	BENCHMARK_TUI_MAX_CANDIDATES,
-	BENCHMARK_TUI_MAX_PROVENANCE_PER_CANDIDATE,
-	MODEL_RANKING_DEFAULT_CONTEXT_WEIGHT,
-	MODEL_RANKING_DEFAULT_COST_WEIGHT,
-	MODEL_RANKING_DEFAULT_LATENCY_WEIGHT,
-	MODEL_RANKING_DEFAULT_QUALITY_WEIGHT,
-	MODEL_RANKING_DEFAULT_RELIABILITY_WEIGHT,
-	type ModelCandidate,
-	type ModelRankingResult,
-	type ModelTaskDomain,
-	type ModelTaskType,
-	type RankedModel,
-	type UtilityComponentName,
-} from "@danypops/jittor";
-import { sessionSecretField } from "./session-identity.ts";
-
-export interface BenchmarkPanelClient {
-	call(operation: string, input: unknown): Promise<any>;
-}
-
-interface BenchmarkTheme {
-	fg(color: string, text: string): string;
-	bold(text: string): string;
-}
-
-type BenchmarkPanelAction = "refresh" | "close";
-
-const COMPONENT_LABELS: Record<UtilityComponentName, string> = { quality: "Q", cost: "$", latency: "L", context: "C", reliability: "R" };
-
-function componentText(item: RankedModel): string {
-	return item.components.map((component) => `${COMPONENT_LABELS[component.name]} ${component.score === null ? "?" : component.score.toFixed(3)}`).join(" · ");
-}
-
-function candidateLines(item: RankedModel, index: number, currentIdentity: string): string[] {
-	const current = item.identity.startsWith(`${currentIdentity}:`);
-	const localSamples = item.components.find((component) => component.name === "reliability")?.evidenceCount ?? 0;
-	const provenance = item.provenance.slice(0, BENCHMARK_TUI_MAX_PROVENANCE_PER_CANDIDATE).map((source) => `${source.sourceId}@${source.revision} ${source.freshness}`).join(" · ");
-	return [
-		` ${index + 1}. ${item.identity}${index === 0 ? "  recommended" : ""}${current ? "  current" : ""}`,
-		`    utility ${item.utility === null ? "?" : item.utility.toFixed(3)} · confidence ${(item.confidence * 100).toFixed(0)}% · ${componentText(item)}`,
-		`    local n=${localSamples}${provenance ? ` · ${provenance}` : " · no external provenance"}`,
-	];
-}
-
-export function renderBenchmarkView(result: ModelRankingResult, currentIdentity: string, width: number, theme: BenchmarkTheme): string[] {
-	const safeWidth = Math.max(1, width);
-	const shown = result.ranked.slice(0, BENCHMARK_TUI_MAX_CANDIDATES);
-	const currentIndex = result.ranked.findIndex((item) => item.identity.startsWith(`${currentIdentity}:`));
-	const recommended = result.ranked[0];
-	const reason = recommended && currentIndex > 0
-		? `Recommendation differs from current: ${recommended.identity} ranks #1; current ranks #${currentIndex + 1}.`
-		: recommended && currentIndex === 0 ? "Current model is the top recommendation." : "Current model is outside the ranked candidates.";
-	const lines = [
-		theme.fg("borderMuted", "─".repeat(safeWidth)),
-		theme.bold("Jittor Benchmark Recommendations"),
-		result.scopeAuthority === "exact-session" ? "Scope: exact session" : "Scope: available models · ADVISORY (exact session scope unavailable)",
-		`Domain: ${result.domain} · Type: ${result.type} · evidence ${result.completeness}`,
-		reason,
-		...shown.flatMap((item, index) => candidateLines(item, index, currentIdentity)),
-		...(result.ranked.length > shown.length ? [` … ${result.ranked.length - shown.length} more candidates omitted`] : []),
-		...(result.scopeWarning ? [result.scopeWarning] : []),
-		theme.fg("dim", "r refresh · Esc close"),
-		theme.fg("borderMuted", "─".repeat(safeWidth)),
-	];
-	return lines.map((line) => truncateToWidth(line, safeWidth, "…"));
-}
-
-export async function showBenchmarkPanel(
-	ctx: ExtensionCommandContext,
-	client: BenchmarkPanelClient,
-	candidates: ModelCandidate[],
-	currentIdentity: string,
-	domain: ModelTaskDomain,
-	type: ModelTaskType,
-): Promise<void> {
-	for (;;) {
-		const session_id = ctx.sessionManager.getSessionId();
-		const result = await client.call("models.rank", {
-			candidates,
-			session_id,
-			...sessionSecretField(session_id),
-			scopeAuthority: "available-models",
-			domain,
-			type,
-			budgetPressure: 0,
-			weights: {
-				quality: MODEL_RANKING_DEFAULT_QUALITY_WEIGHT,
-				cost: MODEL_RANKING_DEFAULT_COST_WEIGHT,
-				latency: MODEL_RANKING_DEFAULT_LATENCY_WEIGHT,
-				context: MODEL_RANKING_DEFAULT_CONTEXT_WEIGHT,
-				reliability: MODEL_RANKING_DEFAULT_RELIABILITY_WEIGHT,
-			},
-			sourceIds: ["openrouter-models", "lmarena-hf", "artificial-analysis-direct", "openrouter-design-arena"],
-		}) as ModelRankingResult;
-		if (ctx.mode !== "tui") {
-			ctx.ui.notify(renderBenchmarkView(result, currentIdentity, 100, { fg: (_color, text) => text, bold: (text) => text }).join("\n"), "info");
-			return;
-		}
-		const action = await ctx.ui.custom<BenchmarkPanelAction>((_tui, theme, _keybindings, done) => ({
-			invalidate() {},
-			render(width: number): string[] { return renderBenchmarkView(result, currentIdentity, width, theme); },
-			handleInput(data: string): void {
-				if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) done("close");
-				else if (data === "r") done("refresh");
-			},
-		}));
-		if (!action || action === "close") return;
-		await client.call("benchmark.refresh", { force: true });
-	}
-}

package/extension/src/context-report.ts

@@ -1,49 +0,0 @@
-import { buildContextRows, type ContextSegment as MalevichContextSegment } from "malevich-tui-components";
-import type { ContextBreakdown } from "./context-breakdown.ts";
-import type { ContextSegment } from "@danypops/jittor";
-
-/** Bounds how many items render per segment in the plain-text fallback -- a notify-mode report is a scan-at-a-glance summary, not a full dump (the interactive TUI view has no such cap, since it scrolls). */
-const MAX_ITEMS_PER_SEGMENT_LINE = 5;
-
-function formatTokens(tokens: number): string {
-	return tokens >= 1_000 ? `${(tokens / 1_000).toFixed(1)}k` : String(tokens);
-}
-
-function percentOf(part: number, whole: number): string {
-	return whole > 0 ? `${((part / whole) * 100).toFixed(1)}%` : "—";
-}
-
-/** Malevich's row builder is confidence-unaware (it's a generic segment/item shape); folding the tier into the label is how it survives into the rendered row text, e.g. "Active Rules [exact-cooperative]". */
-function withConfidenceLabel(segment: ContextSegment): MalevichContextSegment {
-	const items = [...(segment.items ?? [])].sort((left, right) => right.estimatedTokens - left.estimatedTokens).slice(0, MAX_ITEMS_PER_SEGMENT_LINE);
-	return { key: segment.key, label: `${segment.label} [${segment.confidence}]`, estimatedTokens: segment.estimatedTokens, items, unknown: segment.unknown };
-}
-
-/**
- * Plain-text Context Hub report (non-TUI fallback): real usage against the model's effective
- * (reserve-adjusted) budget first -- matching Papyrus's own real-vs-estimate honesty accounting
- * -- an explicit overshoot warning when the known segments' estimates exceed the real total, then
- * every segment heaviest-first. Malevich's buildContextRows renders segments in the order given,
- * so sorting by weight is this function's own policy, not Malevich's.
- */
-export function buildContextReport(breakdown: ContextBreakdown): string {
-	const lines: string[] = [];
-	if (breakdown.totalTokens !== null && breakdown.effectiveBudget !== null) {
-		lines.push(`Real usage: ${formatTokens(breakdown.totalTokens)} / ${formatTokens(breakdown.effectiveBudget)} tokens (${percentOf(breakdown.totalTokens, breakdown.effectiveBudget)} of usable budget)`);
-	} else if (breakdown.totalTokens !== null) {
-		lines.push(`Real usage: ${formatTokens(breakdown.totalTokens)} tokens (model context window unknown)`);
-	} else {
-		lines.push("Real usage: not yet reported -- sizes below are estimates only");
-	}
-	if (breakdown.overshootTokens > 0) lines.push(`Estimates exceed real total by ~${breakdown.overshootTokens} tok -- sizes below are approximate, not exact`);
-
-	const sorted = [...breakdown.segments].sort((left, right) => right.estimatedTokens - left.estimatedTokens).map(withConfidenceLabel);
-	const rows = buildContextRows(sorted, breakdown.totalTokens ?? undefined);
-	if (rows.length === 0) {
-		lines.push("", "(no segments observed yet)");
-		return lines.join("\n");
-	}
-	lines.push("");
-	for (const row of rows) lines.push(row.isHeader ? row.text : `${"  ".repeat(row.depth)}${row.text}`);
-	return lines.join("\n");
-}

package/extension/src/context-view.ts

@@ -1,108 +0,0 @@
-import type { ExtensionCommandContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
-import { matchesKey, truncateToWidth, type TUI } from "@earendil-works/pi-tui";
-import { buildContextRows, renderContextRowLines, renderContextUsageBar, type ContextBarTheme, type ContextRow, type ContextRowsTheme, type ContextSegment as MalevichContextSegment } from "malevich-tui-components";
-import type { ContextSegment } from "@danypops/jittor";
-import type { ContextBreakdown } from "./context-breakdown.ts";
-import { buildContextReport } from "./context-report.ts";
-
-const VISIBLE_ROWS = 24;
-
-/**
- * A dynamically-contributed segment set (any string key from any extension, not a fixed enum)
- * can't use a hardcoded per-key color map the way Papyrus's own ContextViewport did for its
- * fixed seven segments -- this cycles a small categorical palette keyed by a stable hash of the
- * segment key, so the same key always renders the same color within one process without needing
- * every possible contributor's key to be known in advance.
- */
-const PALETTE: ThemeColor[] = ["accent", "success", "syntaxFunction", "warning", "syntaxKeyword", "syntaxType", "muted"];
-
-function paletteColor(key: string): ThemeColor {
-	let hash = 0;
-	for (let index = 0; index < key.length; index += 1) hash = (hash * 31 + key.charCodeAt(index)) >>> 0;
-	return PALETTE[hash % PALETTE.length]!;
-}
-
-function formatTokenCount(tokens: number): string {
-	return tokens >= 1_000 ? `${(tokens / 1_000).toFixed(1)}k` : String(tokens);
-}
-
-function percentOf(part: number, whole: number): string {
-	return whole > 0 ? `${((part / whole) * 100).toFixed(1)}%` : "—";
-}
-
-/** Folds each segment's confidence tier into its label so it survives Malevich's confidence-unaware row builder. */
-function withConfidenceLabel(segment: ContextSegment): MalevichContextSegment {
-	return { key: segment.key, label: `${segment.label} [${segment.confidence}]`, estimatedTokens: segment.estimatedTokens, items: segment.items, unknown: segment.unknown };
-}
-
-class ContextViewport {
-	private offsetY = 0;
-	private readonly rows: ContextRow[];
-	private readonly segments: readonly MalevichContextSegment[];
-
-	constructor(
-		private readonly tui: TUI,
-		private readonly theme: Theme,
-		private readonly breakdown: ContextBreakdown,
-		private readonly close: () => void,
-	) {
-		// Heaviest-first: Malevich renders segments in the order given, so sorting by weight for a
-		// merged multi-producer view is this viewport's own policy, matching context-report.ts.
-		this.segments = [...breakdown.segments].sort((left, right) => right.estimatedTokens - left.estimatedTokens).map(withConfidenceLabel);
-		this.rows = buildContextRows(this.segments, breakdown.totalTokens ?? undefined);
-	}
-
-	invalidate(): void {}
-
-	render(width: number): string[] {
-		const theme = this.theme;
-		const contentWidth = Math.max(1, width);
-		const border = theme.fg("borderMuted", "─".repeat(contentWidth));
-		const lines: string[] = [border, truncateToWidth(theme.fg("accent", theme.bold("Context")), contentWidth, "")];
-
-		const { totalTokens, effectiveBudget } = this.breakdown;
-		if (totalTokens !== null && effectiveBudget !== null) {
-			lines.push(truncateToWidth(`${formatTokenCount(totalTokens)} / ${formatTokenCount(effectiveBudget)} tokens (${percentOf(totalTokens, effectiveBudget)} of usable budget)`, contentWidth, ""));
-		} else if (totalTokens !== null) {
-			lines.push(truncateToWidth(`${formatTokenCount(totalTokens)} tokens (model context window unknown)`, contentWidth, ""));
-		} else {
-			lines.push(theme.fg("dim", "No real usage reported yet — sizes below are estimates only"));
-		}
-
-		const colorFor = (key: string) => (s: string) => theme.fg(paletteColor(key), s);
-		const barTheme: ContextBarTheme = { colorFor, empty: (s) => theme.fg("dim", s) };
-		lines.push(renderContextUsageBar(barTheme, this.segments, contentWidth, effectiveBudget ?? undefined, totalTokens ?? undefined));
-		if (this.breakdown.overshootTokens > 0) {
-			lines.push(truncateToWidth(theme.fg("warning", `Estimates exceed real total by ~${this.breakdown.overshootTokens} tok — sizes below are approximate, not exact`), contentWidth, ""));
-		}
-		lines.push("");
-
-		const rowsTheme: ContextRowsTheme = { colorFor, header: (s) => theme.bold(s) };
-		const visible = this.rows.slice(this.offsetY, this.offsetY + VISIBLE_ROWS);
-		lines.push(...renderContextRowLines(visible, contentWidth, rowsTheme));
-		if (this.rows.length === 0) lines.push(theme.fg("dim", "  (nothing observed yet)"));
-		else lines.push(theme.fg("muted", `  ${Math.min(this.offsetY + VISIBLE_ROWS, this.rows.length)}/${this.rows.length}`));
-
-		lines.push("");
-		lines.push(theme.fg("dim", "↑↓ scroll · esc close"));
-		lines.push(border);
-		return lines;
-	}
-
-	handleInput(data: string): void {
-		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.close(); return; }
-		if (matchesKey(data, "up")) this.offsetY = Math.max(0, this.offsetY - 1);
-		else if (matchesKey(data, "down")) this.offsetY = Math.min(Math.max(0, this.rows.length - VISIBLE_ROWS), this.offsetY + 1);
-		else return;
-		this.tui.requestRender();
-	}
-}
-
-/** Interactive scrollable Context Hub view in TUI mode; the same plain-text report as /context's non-interactive path otherwise. */
-export async function showContextView(ctx: ExtensionCommandContext, breakdown: ContextBreakdown): Promise<void> {
-	if (ctx.mode !== "tui") {
-		ctx.ui.notify(buildContextReport(breakdown), "info");
-		return;
-	}
-	await ctx.ui.custom<void>((tui, theme, _keybindings, done) => new ContextViewport(tui, theme, breakdown, done));
-}