@vanillagreen/pi-qol 1.4.3 → 1.6.0

package/extensions/qol/compaction-handoff.ts

@@ -0,0 +1,190 @@
+// Pre-compaction handoff artifact: writes a JSON snapshot of the previous
+// summary, the most recent task panel state, and recently referenced file
+// paths so an operator can recover continuity if the compaction summary
+// drops something critical. The pure data-building + write logic lives here
+// so it can be unit-tested without the pi-coding-agent / pi-ai peer deps.
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+
+import { QOL_BUDGET_HANDOFF_FOLDER, QOL_BUDGET_HANDOFF_LATEST } from "./constants.js";
+
+export interface QolBudgetHandoff {
+	reason: string;
+	timestamp: number;
+	sessionId: string;
+	tokensBefore?: number;
+	messageCount: number;
+	previousSummary?: string;
+	taskState?: unknown;
+	artifactRefs: string[];
+	model?: string;
+}
+
+function expandHome(input: string): string {
+	if (input === "~") return homedir();
+	if (input.startsWith("~/")) return join(homedir(), input.slice(2));
+	return input;
+}
+
+export function piUserDir(): string {
+	return resolve(expandHome(process.env.PI_CODING_AGENT_DIR?.trim() || "~/.pi/agent"));
+}
+
+export function safeFileName(value: string): string {
+	return value.replace(/[^\w.-]+/g, "_");
+}
+
+export interface HandoffSessionAccessor {
+	getSessionId?: () => string | undefined;
+	getSessionFile?: () => string | undefined;
+	getBranch?: () => unknown[];
+}
+
+export function sessionIdFromManager(sm: HandoffSessionAccessor, fallbackPid: number = process.pid): string {
+	try {
+		const id = typeof sm.getSessionId === "function" ? sm.getSessionId() : undefined;
+		if (typeof id === "string" && id.trim()) return id;
+	} catch {
+		// Stale ctx may throw; fall through to file/pid.
+	}
+	try {
+		const file = typeof sm.getSessionFile === "function" ? sm.getSessionFile() : undefined;
+		if (typeof file === "string" && file.trim()) return basename(file, ".jsonl");
+	} catch {
+		// Same: fall through.
+	}
+	return `ephemeral-${fallbackPid}`;
+}
+
+/**
+ * Walks the branch newest-first and returns the most recent task panel state
+ * embedded in a tool result. Returns undefined when no task state is found.
+ */
+export function findLatestTaskState(branch: unknown[]): unknown {
+	for (let i = branch.length - 1; i >= 0; i -= 1) {
+		const entry = branch[i] as any;
+		if (entry?.type !== "message" || entry.message?.role !== "toolResult") continue;
+		const content = entry.message.content;
+		const parts = Array.isArray(content) ? content : [];
+		for (const part of parts) {
+			if (part?.type !== "toolResult") continue;
+			const details = part?.details;
+			if (details && typeof details === "object" && "state" in (details as Record<string, unknown>)) {
+				return (details as Record<string, unknown>).state;
+			}
+		}
+	}
+	return undefined;
+}
+
+const ARTIFACT_REF_PATTERN = /(?:^|\s|["'`(\[<])((?:\.{1,2}\/|\/|~\/)?[\w.\-+@/]+\.(?:md|json|jsonl|txt|log|ts|tsx|js|jsx|rs|toml|yml|yaml|html|sh|fish|bash|py|go|java|cs|cpp|h|hpp|sql|csv|env|lock|patch|diff))/g;
+
+/**
+ * Collects up to `maxRefs` file path-shaped strings from message contents,
+ * walking newest-first. Used to give the handoff artifact a quick "if you
+ * are recovering, here are recent files" pointer list.
+ */
+export function collectArtifactRefs(branch: unknown[], maxRefs = 20): string[] {
+	const refs = new Set<string>();
+	for (let i = branch.length - 1; i >= 0 && refs.size < maxRefs; i -= 1) {
+		const entry = branch[i] as any;
+		if (entry?.type !== "message") continue;
+		const content = entry.message?.content;
+		const parts = Array.isArray(content) ? content : [];
+		for (const part of parts) {
+			const text = typeof part?.text === "string" ? part.text : typeof part?.thinking === "string" ? part.thinking : "";
+			if (!text) continue;
+			ARTIFACT_REF_PATTERN.lastIndex = 0;
+			let match: RegExpExecArray | null;
+			while ((match = ARTIFACT_REF_PATTERN.exec(text)) !== null && refs.size < maxRefs) {
+				if (match[1]) refs.add(match[1]);
+			}
+		}
+	}
+	return Array.from(refs);
+}
+
+export interface BuildHandoffInput {
+	reason: string;
+	sessionManager: HandoffSessionAccessor;
+	preparation?: {
+		messagesToSummarize?: unknown[];
+		turnPrefixMessages?: unknown[];
+		previousSummary?: string;
+		tokensBefore?: number;
+	};
+	timestamp?: number;
+}
+
+export function buildBudgetHandoff(input: BuildHandoffInput): QolBudgetHandoff {
+	const preparation = input.preparation ?? {};
+	const messageCount = (preparation.messagesToSummarize?.length ?? 0) + (preparation.turnPrefixMessages?.length ?? 0);
+	let branch: unknown[] = [];
+	try {
+		const raw = typeof input.sessionManager.getBranch === "function" ? input.sessionManager.getBranch() : [];
+		branch = Array.isArray(raw) ? raw : [];
+	} catch {
+		branch = [];
+	}
+	return {
+		artifactRefs: collectArtifactRefs(branch),
+		messageCount,
+		previousSummary: preparation.previousSummary,
+		reason: input.reason,
+		sessionId: sessionIdFromManager(input.sessionManager),
+		taskState: findLatestTaskState(branch),
+		timestamp: input.timestamp ?? Date.now(),
+		tokensBefore: typeof preparation.tokensBefore === "number" ? preparation.tokensBefore : undefined,
+	};
+}
+
+export interface HandoffWriteResult {
+	path?: string;
+	latestPath?: string;
+	error?: string;
+}
+
+export function handoffStampedPath(baseDir: string, timestamp: number): string {
+	return join(baseDir, `${new Date(timestamp).toISOString().replace(/[:.]/g, "-")}.json`);
+}
+
+export function handoffBaseDir(sessionId: string, root: string = piUserDir()): string {
+	return join(root, "vstack", "sessions", safeFileName(sessionId), QOL_BUDGET_HANDOFF_FOLDER);
+}
+
+export interface WriteHandoffOptions {
+	enabled: boolean;
+	root?: string;
+	/** Injection point so tests can stub fs without mocking node:fs. */
+	writer?: (path: string, payload: string) => void;
+	mkdir?: (path: string) => void;
+}
+
+function defaultMkdir(path: string): void {
+	mkdirSync(path, { recursive: true, mode: 0o700 });
+}
+
+function defaultWriter(path: string, payload: string): void {
+	writeFileSync(path, payload, { mode: 0o600 });
+}
+
+export function writeBudgetHandoffArtifact(handoff: QolBudgetHandoff, options: WriteHandoffOptions): HandoffWriteResult {
+	if (!options.enabled) return {};
+	const baseDir = handoffBaseDir(handoff.sessionId, options.root);
+	const stampedPath = handoffStampedPath(baseDir, handoff.timestamp);
+	const latestPath = join(dirname(baseDir), basename(baseDir), QOL_BUDGET_HANDOFF_LATEST);
+	const mkdir = options.mkdir ?? defaultMkdir;
+	const writer = options.writer ?? defaultWriter;
+	try {
+		mkdir(baseDir);
+		const payload = JSON.stringify(handoff, null, 2);
+		writer(stampedPath, payload);
+		writer(latestPath, payload);
+		return { latestPath, path: stampedPath };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { error: message };
+	}
+}

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);