@vanillagreen/pi-qol 1.4.2 → 1.5.0

package/extensions/qol/compaction.ts

@@ -2,11 +2,30 @@ import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { complete, type Message } from "@earendil-works/pi-ai";
 import { convertToLlm, serializeConversation, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
+	DEFAULT_BUDGET_GUARD_PERCENT,
+	DEFAULT_BUDGET_GUARD_TOKENS,
+	DEFAULT_BUDGET_MAX_INPUT_CHARS,
 	DEFAULT_COMPACTION_MAX_TOKENS,
 	DEFAULT_COMPACTION_MODEL,
 	DEFAULT_IDLE_COMPACTION_THRESHOLD_TOKENS,
 	QOL_COMPACTION_SYSTEM_PROMPT,
 } from "./constants.js";
+import {
+	chunkConversationText as chunkConversationTextRaw,
+	computeBudgetTrigger,
+	isBudgetGuardCompaction,
+	orchestrateChunkedSummary,
+	type BudgetTrigger,
+	type SummarizeOutcome,
+	type SummarizeRequest,
+	type TranscriptRiskResult,
+} from "./budget-guard.js";
+import {
+	buildBudgetHandoff as buildBudgetHandoffData,
+	writeBudgetHandoffArtifact as writeBudgetHandoffArtifactRaw,
+	type HandoffWriteResult,
+	type QolBudgetHandoff,
+} from "./compaction-handoff.js";
 import { settingBoolean, settingNumber, settingString } from "./settings.js";
 import { stringifyError } from "./util.js";
 
@@ -95,7 +114,7 @@ async function summarizeWithRemote(endpoint: string, systemPrompt: string, promp
 }
 
 export function resolveConfiguredModel(ctx: ExtensionContext, configured: string): any | undefined {
-	if (!configured || configured === "current") return ctx.model;
+	if (!configured || configured.trim().toLowerCase() === "current") return ctx.model;
 	const withoutThinking = configured.replace(/:(off|minimal|low|medium|high|xhigh)$/i, "");
 	const slash = withoutThinking.indexOf("/");
 	if (slash > 0) return ctx.modelRegistry.find(withoutThinking.slice(0, slash), withoutThinking.slice(slash + 1));
@@ -111,20 +130,20 @@ export function modelLabel(model: any): string {
 	return model ? `${model.provider}/${model.id}` : "unknown model";
 }
 
-export async function generateQolSummary(ctx: ExtensionContext, options: {
-	conversationText: string;
-	customInstructions?: string;
-	previousSummary?: string;
-	maxTokens?: number;
-	model?: string;
-	purpose: QolSummaryPurpose;
-	signal?: AbortSignal;
-}): Promise<{ model: string; summary: string; via: "model" | "remote" }> {
-	const maxTokens = Math.max(256, Math.floor(options.maxTokens ?? settingNumber("compaction.maxTokens", DEFAULT_COMPACTION_MAX_TOKENS, ctx.cwd)));
+export function budgetMaxInputChars(ctx: ExtensionContext): number {
+	const raw = Math.floor(settingNumber("compaction.maxInputChars", DEFAULT_BUDGET_MAX_INPUT_CHARS, ctx.cwd));
+	// 0 or negative disables chunking. Anything above the hard floor is honored.
+	return raw <= 0 ? 0 : Math.max(20_000, raw);
+}
+
+export const chunkConversationText = chunkConversationTextRaw;
+export type { QolBudgetHandoff } from "./compaction-handoff.js";
+
+async function singleShotSummary(ctx: ExtensionContext, request: SummarizeRequest, options: { maxTokens: number; model?: string; purpose: QolSummaryPurpose; signal?: AbortSignal }): Promise<SummarizeOutcome> {
 	const promptText = buildSummaryPrompt({
-		conversationText: options.conversationText,
-		customInstructions: options.customInstructions,
-		previousSummary: settingBoolean("compaction.includePreviousSummary", true, ctx.cwd) ? options.previousSummary : undefined,
+		conversationText: request.text,
+		customInstructions: request.customInstructions,
+		previousSummary: settingBoolean("compaction.includePreviousSummary", true, ctx.cwd) ? request.previousSummary : undefined,
 		profile: compactionProfile(ctx.cwd),
 		purpose: options.purpose,
 	});
@@ -132,7 +151,7 @@ export async function generateQolSummary(ctx: ExtensionContext, options: {
 	const remoteEndpoint = settingString("compaction.remoteEndpoint", "", ctx.cwd);
 	if (settingBoolean("compaction.remoteEnabled", false, ctx.cwd) && remoteEndpoint) {
 		try {
-			const summary = await summarizeWithRemote(remoteEndpoint, QOL_COMPACTION_SYSTEM_PROMPT, promptText, maxTokens, options.signal);
+			const summary = await summarizeWithRemote(remoteEndpoint, QOL_COMPACTION_SYSTEM_PROMPT, promptText, options.maxTokens, options.signal);
 			return { model: remoteEndpoint, summary, via: "remote" };
 		} catch (error) {
 			compactionNotify(ctx, `Remote compaction failed, trying model fallback: ${stringifyError(error)}`, "warning");
@@ -154,7 +173,7 @@ export async function generateQolSummary(ctx: ExtensionContext, options: {
 	const response = await complete(
 		model,
 		{ messages: [message], systemPrompt: QOL_COMPACTION_SYSTEM_PROMPT },
-		{ apiKey: auth.apiKey, headers: auth.headers, maxTokens, signal: options.signal },
+		{ apiKey: auth.apiKey, headers: auth.headers, maxTokens: options.maxTokens, signal: options.signal },
 	);
 	const summary = response.content
 		.filter((content): content is { type: "text"; text: string } => content.type === "text")
@@ -164,13 +183,79 @@ export async function generateQolSummary(ctx: ExtensionContext, options: {
 	return { model: modelLabel(model), summary, via: "model" };
 }
 
+export async function generateQolSummary(ctx: ExtensionContext, options: {
+	conversationText: string;
+	customInstructions?: string;
+	previousSummary?: string;
+	maxTokens?: number;
+	model?: string;
+	purpose: QolSummaryPurpose;
+	signal?: AbortSignal;
+	/** Internal: set true on recursive summary-of-summaries pass to skip rechunking. */
+	skipChunking?: boolean;
+}): Promise<{ model: string; summary: string; via: "model" | "remote"; chunkCount?: number; reduceLevels?: number; requestCount?: number }> {
+	const maxTokens = Math.max(256, Math.floor(options.maxTokens ?? settingNumber("compaction.maxTokens", DEFAULT_COMPACTION_MAX_TOKENS, ctx.cwd)));
+	const maxInputChars = budgetMaxInputChars(ctx);
+	const summarize = (request: SummarizeRequest) => singleShotSummary(ctx, request, {
+		maxTokens,
+		model: options.model,
+		purpose: options.purpose,
+		signal: options.signal,
+	});
+	if (options.skipChunking || maxInputChars <= 0 || options.conversationText.length <= maxInputChars) {
+		return summarize({
+			customInstructions: options.customInstructions,
+			previousSummary: options.previousSummary,
+			skipChunking: true,
+			text: options.conversationText,
+		});
+	}
+	const orchestrated = await orchestrateChunkedSummary({
+		customInstructions: options.customInstructions,
+		maxInputChars,
+		notify: (message, level = "info") => compactionNotify(ctx, message, level),
+		previousSummary: options.previousSummary,
+		signal: options.signal,
+		summarize,
+		text: options.conversationText,
+	});
+	return orchestrated;
+}
+
+export function buildBudgetHandoff(ctx: ExtensionContext, options: {
+	reason: string;
+	preparation?: { messagesToSummarize?: AgentMessage[]; turnPrefixMessages?: AgentMessage[]; previousSummary?: string; tokensBefore?: number };
+}): QolBudgetHandoff {
+	return buildBudgetHandoffData({
+		preparation: options.preparation,
+		reason: options.reason,
+		sessionManager: ctx.sessionManager as any,
+	});
+}
+
+export function writeBudgetHandoffArtifact(ctx: ExtensionContext, handoff: QolBudgetHandoff): HandoffWriteResult {
+	const enabled = settingBoolean("compaction.handoffArtifactEnabled", true, ctx.cwd);
+	const result = writeBudgetHandoffArtifactRaw(handoff, { enabled });
+	if (result.error) {
+		compactionNotify(ctx, `QOL handoff artifact write failed: ${result.error}`, "warning");
+	}
+	return result;
+}
+
 export async function handleQolCompaction(event: any, ctx: ExtensionContext): Promise<any> {
-	if (!settingBoolean("compaction.customEnabled", false, ctx.cwd)) return undefined;
+	const isBudgetGuard = isBudgetGuardCompaction(event?.customInstructions);
+	// Budget-guard-triggered compactions force the QOL bounded path so the
+	// chunked summarizer + handoff artifact always run, even when the user
+	// has not flipped compaction.customEnabled on.
+	if (!isBudgetGuard && !settingBoolean("compaction.customEnabled", false, ctx.cwd)) return undefined;
 	const preparation = event.preparation ?? {};
 	const messages = [...(preparation.messagesToSummarize ?? []), ...(preparation.turnPrefixMessages ?? [])];
 	if (messages.length === 0) return undefined;
 	const tokensBefore = typeof preparation.tokensBefore === "number" ? preparation.tokensBefore : 0;
-	compactionNotify(ctx, `QOL compaction: summarizing ${messages.length} message(s), ${tokensBefore.toLocaleString()} token(s).`, "info");
+	const handoff = buildBudgetHandoff(ctx, { preparation, reason: event.customInstructions ?? "session_before_compact" });
+	const handoffResult = writeBudgetHandoffArtifact(ctx, handoff);
+	const sourceLabel = isBudgetGuard ? "pi-qol budget-guard" : "pi-qol";
+	compactionNotify(ctx, `QOL compaction: summarizing ${messages.length} message(s), ${tokensBefore.toLocaleString()} token(s)${isBudgetGuard ? " (budget guard)" : ""}.`, "info");
 	try {
 		const conversationText = serializeMessagesForSummary(messages);
 		const result = await generateQolSummary(ctx, {
@@ -181,14 +266,22 @@ export async function handleQolCompaction(event: any, ctx: ExtensionContext): Pr
 			signal: event.signal,
 		});
 		if (!result.summary.trim()) throw new Error("Compaction summary was empty");
-		compactionNotify(ctx, `QOL compaction complete via ${result.via}: ${result.model}`, "info");
+		const chunkSuffix = result.chunkCount && result.chunkCount > 1 ? ` (${result.chunkCount} chunks, ${result.reduceLevels ?? 1} reduce level${(result.reduceLevels ?? 1) === 1 ? "" : "s"})` : "";
+		compactionNotify(ctx, `QOL compaction complete via ${result.via}: ${result.model}${chunkSuffix}`, "info");
 		return {
 			compaction: {
 				details: {
+					chunkCount: result.chunkCount,
+					handoffArtifact: handoffResult.path,
+					handoffArtifactLatest: handoffResult.latestPath,
+					handoffArtifactError: handoffResult.error,
 					messageCount: messages.length,
 					model: result.model,
 					profile: compactionProfile(ctx.cwd),
-					source: "pi-qol",
+					reduceLevels: result.reduceLevels,
+					requestCount: result.requestCount,
+					source: sourceLabel,
+					trigger: isBudgetGuard ? "budget-guard" : "session_before_compact",
 					via: result.via,
 				},
 				firstKeptEntryId: preparation.firstKeptEntryId,
@@ -262,3 +355,25 @@ export function compactionTriggerReason(ctx: ExtensionContext): string | undefin
 	if (usage.tokens >= idleLimit) return `${usage.tokens.toLocaleString()} tokens >= ${Math.floor(idleLimit).toLocaleString()} idle threshold`;
 	return undefined;
 }
+
+export type BudgetGuardTrigger = BudgetTrigger;
+export type TranscriptRiskState = TranscriptRiskResult;
+
+/**
+ * Budget guard fires on agent_end (no idle wait) when context usage crosses a
+ * percent of the model window or an absolute token limit. Returns a stable key
+ * per crossing so the caller can suppress repeated triggers while usage stays
+ * above the threshold.
+ */
+export function budgetGuardTrigger(ctx: ExtensionContext): BudgetGuardTrigger | undefined {
+	if (!settingBoolean("compaction.budgetGuardEnabled", true, ctx.cwd)) return undefined;
+	const usage = contextUsage(ctx);
+	if (!usage) return undefined;
+	return computeBudgetTrigger({
+		contextWindow: usage.contextWindow,
+		enabled: true,
+		percentLimit: settingNumber("compaction.budgetPercent", DEFAULT_BUDGET_GUARD_PERCENT, ctx.cwd),
+		tokenLimit: settingNumber("compaction.budgetTokens", DEFAULT_BUDGET_GUARD_TOKENS, ctx.cwd),
+		tokens: usage.tokens,
+	});
+}

package/extensions/qol/constants.ts

@@ -33,11 +33,33 @@ export const DEFAULT_NOTIFICATION_COOLDOWN_SECONDS = 8;
 export const DEFAULT_NOTIFICATION_BODY_MAX_CHARS = 240;
 export const DEFAULT_TMUX_MESSAGE_DURATION_MS = 5000;
 
-export const DEFAULT_COMPACTION_MODEL = "google/gemini-2.5-flash";
+export const DEFAULT_COMPACTION_MODEL = "current";
 export const DEFAULT_COMPACTION_MAX_TOKENS = 8192;
 export const DEFAULT_IDLE_COMPACTION_THRESHOLD_TOKENS = 200000;
 export const DEFAULT_IDLE_COMPACTION_SECONDS = 300;
 
+// Budget guard: catches long autonomous sessions before they hit provider/buffer
+// limits. Fires on agent_end (no idle wait) when usage crosses a percent or
+// absolute token threshold. One notification + one compaction trigger per
+// threshold crossing so it does not loop.
+export const DEFAULT_BUDGET_GUARD_PERCENT = 85;
+export const DEFAULT_BUDGET_GUARD_TOKENS = -1;
+
+// Chunked summary input caps. Long transcripts are split on paragraph
+// boundaries (which align with serializeConversation message separators) into
+// chunks of at most this many characters, summarized chunk-by-chunk in the
+// original order, then a summary-of-summaries reduce pass merges them with
+// "prefer the most recent" semantics so recency is preserved.
+export const DEFAULT_BUDGET_MAX_INPUT_CHARS = 240_000;
+
+// Transcript-risk warning: shown in /context when the serialized payload of
+// messages-to-send is larger than this character budget, even if token count is
+// still below the model window.
+export const DEFAULT_TRANSCRIPT_RISK_WARN_CHARS = 600_000;
+
+export const QOL_BUDGET_HANDOFF_FOLDER = "pi-qol/handoff";
+export const QOL_BUDGET_HANDOFF_LATEST = "latest.json";
+
 export const DEFAULT_PERMISSION_GATE_COMMANDS = "rm -Rf";
 export const DEFAULT_PERMISSION_GATE_PREVIEW_LINES = 12;
 export const DEFAULT_PERMISSION_GATE_PREVIEW_CHARS = 1200;

package/extensions/qol/context-usage.ts

@@ -2,6 +2,12 @@ import { existsSync, readFileSync } from "node:fs";
 import { isAbsolute } from "node:path";
 import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { TranscriptRiskResult } from "./budget-guard.js";
+import { DEFAULT_TRANSCRIPT_RISK_WARN_CHARS } from "./constants.js";
+import { settingNumber } from "./settings.js";
+import { transcriptRiskState } from "./transcript-risk.js";
+
+type TranscriptRiskState = TranscriptRiskResult;
 
 type QolContextColor = "accent" | "success" | "warning" | "error" | "muted" | "dim" | "borderMuted" | "text";
 
@@ -53,6 +59,7 @@ export interface QolContextUsageMessageDetails {
 		user: number;
 	};
 	compactSummaries: QolContextDetailItem[];
+	transcriptRisk?: TranscriptRiskState;
 	note?: string;
 }
 
@@ -319,6 +326,14 @@ function qcuExtractProjectAgents(systemPrompt: string): { agents: QolContextDeta
 	return { agents: qcuUniqDetails(agents), tokens: qcuEstimateTokens(section) };
 }
 
+function qcuMessagesForRisk(ctx: ExtensionCommandContext): any[] {
+	const sm = ctx.sessionManager as any;
+	const built = typeof sm.buildSessionContext === "function" ? sm.buildSessionContext() : undefined;
+	if (Array.isArray(built?.messages)) return built.messages;
+	const branch = Array.isArray(sm.getBranch?.()) ? sm.getBranch() : [];
+	return branch.filter((entry: any) => entry?.type === "message").map((entry: any) => entry.message);
+}
+
 export function buildQolContextUsageDetails(pi: ExtensionAPI, ctx: ExtensionCommandContext, promptOptions: unknown): QolContextUsageMessageDetails | undefined {
 	const usage = ctx.getContextUsage?.() as { contextWindow?: unknown; percent?: unknown; tokens?: unknown } | undefined;
 	const tokens = Number(usage?.tokens);
@@ -355,6 +370,8 @@ export function buildQolContextUsageDetails(pi: ExtensionAPI, ctx: ExtensionComm
 	const modelId = typeof model.id === "string" ? model.id : typeof model.model === "string" ? model.model : "unknown";
 	const modelName = typeof model.name === "string" ? model.name : modelId;
 	const thinking = typeof (pi as any).getThinkingLevel === "function" ? (pi as any).getThinkingLevel() : undefined;
+	const transcriptThreshold = Math.floor(settingNumber("compaction.transcriptRiskWarnChars", DEFAULT_TRANSCRIPT_RISK_WARN_CHARS, ctx.cwd));
+	const transcriptRisk = transcriptRiskState(qcuMessagesForRisk(ctx), transcriptThreshold);
 	return {
 		builtinTools,
 		categories,
@@ -365,6 +382,7 @@ export function buildQolContextUsageDetails(pi: ExtensionAPI, ctx: ExtensionComm
 		freeTokens: safeContextWindow ? Math.max(0, safeContextWindow - tokens) : undefined,
 		mcpTools,
 		messageStats: stats,
+		transcriptRisk: transcriptRisk.chars > 0 || transcriptRisk.error ? transcriptRisk : undefined,
 		model: {
 			contextWindow: safeContextWindow,
 			id: modelId,
@@ -486,6 +504,23 @@ export function renderQolContextUsageMessage(message: any, _options: any, theme:
 			qcuRenderDetailSection(lines, "Context / memory files", details.contextFiles, theme, { limit: 12, showDescriptions: false });
 			qcuRenderDetailSection(lines, "Skills · /skills", details.skills, theme, { empty: "No skill commands discovered.", limit: 14, showDescriptions: false });
 			qcuRenderDetailSection(lines, "Compact buffer", details.compactSummaries, theme, { limit: 6, showDescriptions: false });
+			if (details.transcriptRisk?.error) {
+				const r = details.transcriptRisk;
+				const safe = r.error.replace(/[\x00-\x1f]+/g, " ").slice(0, 200);
+				lines.push("");
+				lines.push(`${theme.fg("warning", theme.bold("Transcript risk"))}`);
+				lines.push(`${qcuBranch(theme, "└")}${theme.fg("warning", `risk calculation failed: ${safe}`)}`);
+			} else if (details.transcriptRisk?.exceeded) {
+				const r = details.transcriptRisk;
+				lines.push("");
+				lines.push(`${theme.fg("warning", theme.bold("Transcript risk"))}`);
+				lines.push(`${qcuBranch(theme, "├")}${theme.fg("warning", `serialized payload ${qcuFormatTokens(Math.ceil(r.chars / 4))} tokens (${r.chars.toLocaleString()} chars) >= ${r.threshold.toLocaleString()} char warn budget`)}`);
+				lines.push(`${qcuBranch(theme, "└")}${theme.fg("muted", "compact soon or raise compaction.transcriptRiskWarnChars to silence")}`);
+			} else if (details.transcriptRisk && details.transcriptRisk.chars > 0) {
+				const r = details.transcriptRisk;
+				lines.push("");
+				lines.push(`${theme.fg("muted", `Transcript payload: ${qcuFormatTokens(Math.ceil(r.chars / 4))} tokens (${r.chars.toLocaleString()} chars / ${r.threshold.toLocaleString()} warn budget).`)}`);
+			}
 			return lines.map((line) => truncateToWidth(line, safeWidth, ""));
 		},
 	};

package/extensions/qol/editor.ts

@@ -3,6 +3,7 @@ import { matchesKey, truncateToWidth, visibleWidth, type AutocompleteItem, type
 import { stripAnsi } from "./ansi.js";
 import { readCavemanBridge } from "./bridges.js";
 import { STATUS_KEY } from "./constants.js";
+import { glyphs } from "./glyphs.js";
 import { statusText, styleImageChips } from "./images.js";
 import { newlineFallbackKey, settingBoolean } from "./settings.js";
 
@@ -101,14 +102,16 @@ function syncQolEditorStatus(
 
 export class QolEditor extends CustomEditor {
 	private readonly statusCache: { last?: string } = {};
+	private readonly ctx: ExtensionContext;
 
 	constructor(
 		tui: TUI,
 		editorTheme: EditorTheme,
 		keybindings: KeybindingsManager,
-		private readonly ctx: ExtensionContext,
+		ctx: ExtensionContext,
 	) {
 		super(tui, editorTheme, keybindings);
+		this.ctx = ctx;
 	}
 
 	handleInput(data: string): void {
@@ -128,15 +131,19 @@ function isEditorBorderLine(line: string): boolean {
 
 export class QolCompactPromptEditor extends CustomEditor {
 	private readonly statusCache: { last?: string } = {};
+	private readonly inputBottomPaddingLines: number;
+	private readonly ctx: ExtensionContext;
 
 	constructor(
 		tui: TUI,
 		editorTheme: EditorTheme,
 		keybindings: KeybindingsManager,
-		private readonly inputBottomPaddingLines: number,
-		private readonly ctx: ExtensionContext,
+		inputBottomPaddingLines: number,
+		ctx: ExtensionContext,
 	) {
 		super(tui, editorTheme, keybindings, { paddingX: 0 });
+		this.inputBottomPaddingLines = inputBottomPaddingLines;
+		this.ctx = ctx;
 	}
 
 	handleInput(data: string): void {
@@ -145,9 +152,10 @@ export class QolCompactPromptEditor extends CustomEditor {
 
 	render(width: number): string[] {
 		syncQolEditorStatus(this.ctx, this.getText(), this.statusCache);
-		const prompt = this.borderColor("π");
+		const promptGlyph = glyphs(this.ctx.cwd).prompt;
+		const prompt = this.borderColor(promptGlyph);
 		const prefix = `${prompt} `;
-		const prefixWidth = visibleWidth("π ");
+		const prefixWidth = visibleWidth(`${promptGlyph} `);
 		const continuationPrefix = " ".repeat(prefixWidth);
 		const innerWidth = Math.max(1, width - prefixWidth);
 		const rendered = super.render(innerWidth);

package/extensions/qol/glyphs.ts

@@ -0,0 +1,122 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+export type GlyphStyle = "unicode" | "ascii";
+export type GlobalGlyphStyleOverride = "inherit" | GlyphStyle;
+
+const LOCAL_CONFIG_ID = "@vanillagreen/pi-qol";
+const GLOBAL_CONFIG_ID = "@vanillagreen/pi-tool-renderer";
+
+function expandHome(input: string): string {
+	if (input === "~") return homedir();
+	if (input.startsWith("~/")) return join(homedir(), input.slice(2));
+	return input;
+}
+
+function projectSettingsPath(cwd: string): string {
+	let current = resolve(cwd);
+	while (true) {
+		const candidate = join(current, ".pi", "settings.json");
+		if (existsSync(candidate)) return candidate;
+		if (existsSync(join(current, ".pi")) || existsSync(join(current, ".git")) || existsSync(join(current, ".vstack-lock.json"))) return candidate;
+		const parent = dirname(current);
+		if (parent === current) return join(resolve(cwd), ".pi", "settings.json");
+		current = parent;
+	}
+}
+
+function piSettingsPaths(cwd = process.cwd()): string[] {
+	const userDir = resolve(expandHome(process.env.PI_CODING_AGENT_DIR?.trim() || "~/.pi/agent"));
+	return [join(userDir, "settings.json"), projectSettingsPath(cwd)];
+}
+
+function readPackageConfig(packageId: string, cwd?: string): Record<string, unknown> {
+	const merged: Record<string, unknown> = {};
+	for (const settingsPath of piSettingsPaths(cwd)) {
+		if (!existsSync(settingsPath)) continue;
+		try {
+			const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+			const config = parsed?.vstack?.extensionManager?.config?.[packageId];
+			if (config && typeof config === "object" && !Array.isArray(config)) Object.assign(merged, config);
+		} catch {
+			// Ignore malformed optional manager config.
+		}
+	}
+	return merged;
+}
+
+function asGlyphStyle(value: unknown): GlyphStyle | undefined {
+	return value === "unicode" || value === "ascii" ? value : undefined;
+}
+
+export function glyphStyle(cwd?: string): GlyphStyle {
+	const globalOverride = readPackageConfig(GLOBAL_CONFIG_ID, cwd).globalGlyphStyleOverride;
+	const forced = asGlyphStyle(globalOverride);
+	if (forced) return forced;
+	const local = readPackageConfig(LOCAL_CONFIG_ID, cwd);
+	return asGlyphStyle(local.glyphStyle) ?? asGlyphStyle(local.treeStyle) ?? "unicode";
+}
+
+export const GLYPHS = {
+	unicode: {
+		frame: { tl: "┏", tr: "┓", bl: "┗", br: "┛", h: "━", v: "┃" },
+		line: "─",
+		tree: { mid: "├─ ", last: "└─ ", stem: "│  ", blank: "   " },
+		bullet: "● ",
+		emptyBullet: "○ ",
+		dot: " · ",
+		ok: "✓",
+		fail: "✗",
+		warn: "▲",
+		diamond: "◆",
+		prompt: "π",
+		ellipsis: "…",
+		arrow: "→",
+		codeBar: "▌",
+	},
+	ascii: {
+		frame: { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" },
+		line: "-",
+		tree: { mid: "|-- ", last: "`-- ", stem: "|  ", blank: "   " },
+		bullet: "* ",
+		emptyBullet: "o ",
+		dot: " - ",
+		ok: "+",
+		fail: "x",
+		warn: "!",
+		diamond: "*",
+		prompt: "pi",
+		ellipsis: "...",
+		arrow: "->",
+		codeBar: "|",
+	},
+} as const;
+
+export function glyphs(cwd?: string): (typeof GLYPHS)[GlyphStyle] {
+	return GLYPHS[glyphStyle(cwd)];
+}
+
+export function truncateIndicator(cwd?: string): string {
+	return glyphs(cwd).ellipsis;
+}
+
+export function truncateText(text: string, maxChars: number, cwd?: string): string {
+	if (text.length <= maxChars) return text;
+	const indicator = truncateIndicator(cwd);
+	return `${text.slice(0, Math.max(0, maxChars - indicator.length))}${indicator}`;
+}
+
+export function dot(cwd?: string): string {
+	return glyphs(cwd).dot;
+}
+
+export function treeGlyph(branch: "├" | "└" | "│", cwd?: string): string {
+	const tree = glyphs(cwd).tree;
+	if (branch === "│") return tree.stem;
+	return branch === "└" ? tree.last : tree.mid;
+}
+
+export function frameGlyphs(cwd?: string): (typeof GLYPHS)[GlyphStyle]["frame"] {
+	return glyphs(cwd).frame;
+}

package/extensions/qol/session-search/component.ts

@@ -105,6 +105,12 @@ function isPrintableInput(data: string): boolean {
 }
 
 export class QolSessionSearchComponent {
+	private readonly done: (action: QolSessionPaletteAction) => void;
+	private readonly tui: { requestRender(): void; terminal?: { rows?: number } };
+	private readonly theme: Theme;
+	private readonly sessions: QolSessionSearchSession[];
+	private readonly cwd: string;
+	private readonly currentModel: QolModelInfo | undefined;
 	private screen: "search" | "messages" | "actions" | "confirmContext" | "confirmFork" | "confirmModel" = "search";
 	private searchState: QolSessionSearchState;
 	private messagesState: QolSessionMessagesState | undefined;
@@ -116,14 +122,20 @@ export class QolSessionSearchComponent {
 
 
 	constructor(
-		private readonly done: (action: QolSessionPaletteAction) => void,
-		private readonly tui: { requestRender(): void; terminal?: { rows?: number } },
-		private readonly theme: Theme,
-		private readonly sessions: QolSessionSearchSession[],
-		private readonly cwd: string,
+		done: (action: QolSessionPaletteAction) => void,
+		tui: { requestRender(): void; terminal?: { rows?: number } },
+		theme: Theme,
+		sessions: QolSessionSearchSession[],
+		cwd: string,
 		initialQuery = "",
-		private readonly currentModel: QolModelInfo | undefined = undefined,
+		currentModel: QolModelInfo | undefined = undefined,
 	) {
+		this.done = done;
+		this.tui = tui;
+		this.theme = theme;
+		this.sessions = sessions;
+		this.cwd = cwd;
+		this.currentModel = currentModel;
 		const query = initialQuery.trim();
 		const scope = defaultSessionSearchScope(cwd);
 		const scopedSessions = this.sessionsForScope(scope);
@@ -878,18 +890,28 @@ export class QolSessionSearchComponent {
 }
 
 export class QolSessionSearchLoadingComponent {
+	private readonly tui: { requestRender(): void };
+	private readonly theme: Theme;
+	private readonly title: string;
+	private readonly message: string;
+	private readonly done: (value: null) => void;
 	private readonly controller = new AbortController();
 	private readonly startedAt = Date.now();
 	private frame = 0;
 	private timer: ReturnType<typeof setInterval> | undefined;
 
 	constructor(
-		private readonly tui: { requestRender(): void },
-		private readonly theme: Theme,
-		private readonly title: string,
-		private readonly message: string,
-		private readonly done: (value: null) => void,
+		tui: { requestRender(): void },
+		theme: Theme,
+		title: string,
+		message: string,
+		done: (value: null) => void,
 	) {
+		this.tui = tui;
+		this.theme = theme;
+		this.title = title;
+		this.message = message;
+		this.done = done;
 		this.timer = setInterval(() => {
 			this.frame += 1;
 			this.tui.requestRender();

package/extensions/qol/status-message.ts

@@ -8,6 +8,7 @@ import {
 	DEFAULT_PERMISSION_GATE_PREVIEW_LINES,
 } from "./constants.js";
 import { currentEditorText } from "./editor.js";
+import { glyphs } from "./glyphs.js";
 import { attachmentLabels } from "./images.js";
 import { permissionGateCommands } from "./permission-gate.js";
 import { autoRenameEnabled } from "./session-rename.js";
@@ -19,7 +20,7 @@ export function statusMessage(ctx: ExtensionContext): string {
 	const searchShortcut = sessionSearchShortcut(ctx.cwd);
 	return [
 		"Pi QOL status",
-		`Statusline: ${settingBoolean("replaceFooter", true, ctx.cwd) ? "replaces footer" : "footer preserved"}; prompt=${settingBoolean("compactPrompt", true, ctx.cwd) ? "π compact" : "default chrome"}`,
+		`Statusline: ${settingBoolean("replaceFooter", true, ctx.cwd) ? "replaces footer" : "footer preserved"}; prompt=${settingBoolean("compactPrompt", true, ctx.cwd) ? `${glyphs(ctx.cwd).prompt} compact` : "default chrome"}`,
 		`shift+enter newline: ${settingBoolean("newlineOnShiftEnter", true, ctx.cwd) ? "enabled" : "disabled"}`,
 		`Fallback newline key: ${newlineFallbackKey(ctx.cwd)}`,
 		`Pending queue preview: ${settingBoolean("pendingQueue.asciiGreen", true, ctx.cwd) ? "ANSI green" : "Pi default"}`,

package/extensions/qol/statusline.ts

@@ -5,6 +5,7 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { subagentStatuslineMarker } from "./agent-statusline.js";
 import { stripAnsi } from "./ansi.js";
 import { readCavemanBridge } from "./bridges.js";
+import { glyphs } from "./glyphs.js";
 import { CAVEMAN_ICON_ACTIVE, CAVEMAN_ICON_INACTIVE } from "./constants.js";
 import { settingBoolean, settingNumber } from "./settings.js";
 
@@ -136,14 +137,14 @@ export function sessionNameHeader(width: number, pi: ExtensionAPI, theme: Pick<T
 	const prefixPlain = "Session ";
 	const prefix = theme.fg("muted", prefixPlain);
 	const innerWidth = Math.max(1, width - visibleWidth(prefixPlain) - 2);
-	const inner = truncateToWidth(name, innerWidth, "…");
+	const inner = truncateToWidth(name, innerWidth, glyphs().ellipsis);
 	const plain = ` ${inner} `;
 	const badge = theme.bg("selectedBg", theme.fg("text", plain));
 	return [truncateToWidth(`${prefix}${badge}`, width, "")];
 }
 
 export function formatTmuxSessionTitle(sessionName: string): string {
-	return `π ${sessionName}`;
+	return `${glyphs().prompt} ${sessionName}`;
 }
 
 export function tmuxPaneTarget(): string | undefined {
@@ -201,7 +202,7 @@ export function renderStatusLine(width: number, ctx: ExtensionContext, git: GitS
 	const cavemanSegment = caveman ? `${statusSeparator}${cavemanGlyph}` : "";
 	const contextSeparator = caveman ? ` ${statusSeparator}` : "";
 	const leftPlain = `${projectChunk}${statusSeparator}${thinkingChunk}${cavemanSegment}${contextSeparator}${contextChunk.trimStart()}`;
-	const percentPlain = percent === null ? "…%" : `${percent}%`;
+	const percentPlain = percent === null ? `${glyphs(ctx.cwd).ellipsis}%` : `${percent}%`;
 	const subagentMarker = subagentStatuslineMarker(ctx.cwd);
 	const rightPlain = subagentMarker ? `${percentPlain} ${subagentMarker.plain}` : percentPlain;
 	const percentColor = percent === null ? "muted" : percent <= 15 ? "error" : percent <= 30 ? "warning" : "success";
@@ -214,6 +215,6 @@ export function renderStatusLine(width: number, ctx: ExtensionContext, git: GitS
 	const gapWidth = Math.max(minimumGap, width - visibleWidth(leftPlain) - visibleWidth(rightPlain) - 2);
 	const filled = percent === null ? 0 : Math.round(gapWidth * (percent / 100));
 	const empty = Math.max(0, gapWidth - filled);
-	const bar = " ".repeat(empty) + theme.fg("warning", "─".repeat(filled));
+	const bar = " ".repeat(empty) + theme.fg("warning", glyphs(ctx.cwd).line.repeat(filled));
 	return truncateToWidth(`${leftColored} ${bar} ${right}`, width, "");
 }