@danypops/papyrus 0.13.0 → 0.13.2

package/extension/src/context-budget.ts

@@ -5,8 +5,6 @@ import type { Artifact } from "../../src/domain/artifact.ts";
 import { discoverSkillDirectories, scanSkillCatalogFootprint, type SkillCatalogFootprint } from "./skill-catalog-footprint.ts";
 import { ruleInjectionPreview } from "./rules.ts";
 
-const REPORT_MAX_ROWS = 5;
-
 export interface RuleBudgetEntry {
 	id: string;
 	title: string;
@@ -71,11 +69,73 @@ export interface ContextSegmentItem {
 }
 
 export interface ContextSegment {
-	key: "rules" | "tasks" | "skills" | "other";
+	key: "rules" | "tasks" | "skills" | "basePrompt" | "messageHistory" | "other";
 	label: string;
 	estimatedTokens: number;
 	/** Drill-down items, when this segment can be broken down further. Absent for "other" -- an opaque remainder, not a real category. */
 	items?: ContextSegmentItem[];
+	/**
+	 * True when this segment's size is genuinely unmeasured (not yet observed), as opposed to
+	 * measured-and-actually-zero. A display layer that hides zero-token rows to cut noise must
+	 * NOT hide an unknown segment just because its placeholder value happens to be zero --
+	 * that would silently misrepresent "we don't know" as "there is nothing here", the same
+	 * category of honesty problem overshootTokens exists to prevent for the unaccounted bucket.
+	 */
+	unknown?: boolean;
+}
+
+/**
+ * Session branch entries as SessionManager exposes them (docs/session-format.md): a subset
+ * covering only the fields this estimate reads, so this stays testable with plain object
+ * literals instead of importing pi's own session types.
+ */
+export interface SessionBranchEntryLike {
+	type: string;
+	message?: unknown;
+	summary?: string;
+}
+
+function messageContentCharacters(message: unknown): number {
+	if (typeof message !== "object" || message === null) return 0;
+	const record = message as Record<string, unknown>;
+	if (record["role"] === "bashExecution") {
+		// Pi's own context builder excludes "!!"-prefixed bash output from context; match that.
+		if (record["excludeFromContext"] === true) return 0;
+		return String(record["command"] ?? "").length + String(record["output"] ?? "").length;
+	}
+	const content = record["content"];
+	if (typeof content === "string") return content.length;
+	if (!Array.isArray(content)) return 0;
+	let characters = 0;
+	for (const block of content) {
+		if (typeof block !== "object" || block === null) continue;
+		const b = block as Record<string, unknown>;
+		if (b["type"] === "text") characters += String(b["text"] ?? "").length;
+		else if (b["type"] === "thinking") characters += String(b["thinking"] ?? "").length;
+		else if (b["type"] === "toolCall") characters += JSON.stringify(b["arguments"] ?? {}).length;
+		// "image" blocks are deliberately not counted here -- image tokens follow a different,
+		// non-character-based cost model this char/4 estimate cannot represent; this is a real,
+		// documented undercount for image-heavy sessions, not a silent approximation.
+	}
+	return characters;
+}
+
+/**
+ * Estimates the conversation transcript's own context contribution by walking the actual
+ * session branch (docs/session-format.md's buildSessionContext(): message/compaction/
+ * branch_summary entries participate in context, plain "custom" entries do not). This is
+ * character-count estimation like every other Papyrus segment here, not exact -- but it is
+ * real session content, not a guess, and in a long-running session this is very likely the
+ * dominant contributor to "the base prompt, message history, and tool definitions" bucket
+ * that would otherwise stay fully opaque.
+ */
+export function estimateMessageHistoryTokens(branch: ReadonlyArray<SessionBranchEntryLike>): number {
+	let characters = 0;
+	for (const entry of branch) {
+		if (entry.type === "message") characters += messageContentCharacters(entry.message);
+		else if (entry.type === "compaction" || entry.type === "branch_summary") characters += (entry.summary ?? "").length;
+	}
+	return Math.ceil(characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN);
 }
 
 export interface ContextBreakdown {
@@ -85,7 +145,16 @@ export interface ContextBreakdown {
 	contextWindow: number | null;
 	/** contextWindow - reserveTokens, mirroring Pi's own compaction-trigger formula. Null when contextWindow is unknown. */
 	effectiveBudget: number | null;
-	/** rules, tasks, skills, then "other" absorbing whatever real usage the first three don't account for. */
+	/**
+	 * How much the known/estimated segments (rules+tasks+skills+basePrompt+messageHistory)
+	 * exceed the real total, when they do. Zero means no overshoot. This must stay visible
+	 * rather than only being absorbed into "unaccounted" clamping to zero -- a clamped-to-zero
+	 * unaccounted segment does NOT mean tool definitions and framework overhead are actually
+	 * free; it means this estimate's other segments already consumed the entire real budget on
+	 * paper. Hiding that distinction would make a genuinely nonzero cost look like zero.
+	 */
+	overshootTokens: number;
+	/** rules, tasks, skills, basePrompt, messageHistory, then "other" absorbing whatever real usage the rest don't account for. */
 	segments: ContextSegment[];
 }
 
@@ -94,19 +163,27 @@ export interface BuildContextBreakdownInput {
 	contextWindow: number | null;
 	reserveTokens?: number;
 	ruleBudget: ContextBudget["rules"];
-	taskEstimatedTokens: number;
+	/** Open tasks contributing to the injected task-context summary, each sized individually so the Tasks segment can be drilled into like Rules and Skills. */
+	taskItems: ContextSegmentItem[];
 	skills: SkillCatalogFootprint;
+	/** Pi's own base system prompt size, cached from the last observed before_agent_start turn. Null before any turn has run yet. */
+	basePromptEstimatedTokens: number | null;
+	/** From estimateMessageHistoryTokens() against the live session branch. */
+	messageHistoryEstimatedTokens: number;
 }
 
 /**
- * Composes Papyrus's own estimated segments (rules/tasks/skills) against the real total Pi
- * reports, deriving "everything else" (base system prompt, message history, tool definitions
- * -- none of which Papyrus can see or estimate) as the remainder. The remainder is clamped to
- * zero rather than shown negative: char/4 token estimation is approximate, and a small
- * overshoot in the known segments must not display as a nonsensical negative "other" bucket.
- * When the real total is unavailable, "other" is reported as zero and totalTokens surfaces as
- * null so callers can label the whole breakdown as estimate-only rather than silently treating
- * a partial sum as ground truth.
+ * Composes every segment Papyrus can actually measure or estimate (rules, tasks, skills
+ * catalog, cached base-prompt size, and the live session's own message history) against the
+ * real total Pi reports, deriving "unaccounted" (tool definitions and framework overhead --
+ * genuinely invisible to any extension) as the remainder. The remainder is clamped to zero
+ * rather than shown negative -- char/4 token estimation is approximate, and a small overshoot
+ * in the known segments must not display as a nonsensical negative bucket -- but the clamp
+ * amount itself is preserved as overshootTokens rather than silently discarded, so a
+ * consumer can tell "genuinely zero" apart from "our other estimates already exceeded the
+ * real total". When the real total is unavailable, unaccounted is reported as zero and
+ * totalTokens surfaces as null so callers can label the whole breakdown as estimate-only
+ * rather than silently treating a partial sum as ground truth.
  */
 export function buildContextBreakdown(input: BuildContextBreakdownInput): ContextBreakdown {
 	const reserveTokens = input.reserveTokens ?? DEFAULT_RESERVE_TOKENS;
@@ -116,58 +193,45 @@ export function buildContextBreakdown(input: BuildContextBreakdownInput): Contex
 		estimatedTokens: input.ruleBudget.totalEstimatedTokens,
 		items: input.ruleBudget.entries.map((entry) => ({ label: entry.title, estimatedTokens: entry.estimatedTokens })),
 	};
-	const tasks: ContextSegment = { key: "tasks", label: "Papyrus Tasks", estimatedTokens: input.taskEstimatedTokens };
+	const tasks: ContextSegment = {
+		key: "tasks",
+		label: "Papyrus Tasks",
+		estimatedTokens: input.taskItems.reduce((sum, item) => sum + item.estimatedTokens, 0),
+		items: input.taskItems,
+	};
 	const skills: ContextSegment = {
 		key: "skills",
 		label: "Pi Skills catalog",
 		estimatedTokens: input.skills.totalEstimatedTokens,
 		items: input.skills.entries.map((entry) => ({ label: entry.name, estimatedTokens: entry.estimatedTokens })),
 	};
-	const knownTokens = rules.estimatedTokens + tasks.estimatedTokens + skills.estimatedTokens;
+	const basePrompt: ContextSegment = {
+		key: "basePrompt",
+		label: input.basePromptEstimatedTokens === null ? "Base system prompt (not observed yet)" : "Base system prompt (Pi + host instructions)",
+		estimatedTokens: input.basePromptEstimatedTokens ?? 0,
+		...(input.basePromptEstimatedTokens === null ? { unknown: true } : {}),
+	};
+	const messageHistory: ContextSegment = {
+		key: "messageHistory",
+		label: "Conversation message history",
+		estimatedTokens: input.messageHistoryEstimatedTokens,
+	};
+	const knownTokens = rules.estimatedTokens + tasks.estimatedTokens + skills.estimatedTokens + basePrompt.estimatedTokens + messageHistory.estimatedTokens;
+	const overshootTokens = input.totalTokens === null ? 0 : Math.max(0, knownTokens - input.totalTokens);
 	const other: ContextSegment = {
 		key: "other",
-		label: "Everything else (base prompt, message history, tool definitions)",
+		label: overshootTokens > 0
+			? `Unaccounted (tool definitions, framework overhead) -- estimate overshoot: other segments' estimates already exceed the real total by ~${overshootTokens} tokens, so this is a floor, not a real zero`
+			: "Unaccounted (tool definitions, framework overhead)",
 		estimatedTokens: input.totalTokens === null ? 0 : Math.max(0, input.totalTokens - knownTokens),
 	};
 	return {
 		totalTokens: input.totalTokens,
 		contextWindow: input.contextWindow,
 		effectiveBudget: input.contextWindow === null ? null : Math.max(0, input.contextWindow - reserveTokens),
-		segments: [rules, tasks, skills, other],
+		overshootTokens,
+		segments: [rules, tasks, skills, basePrompt, messageHistory, other],
 	};
 }
 
-function truncate(text: string, max: number): string {
-	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-
-/** Pure text formatter, independent of live daemon/filesystem state, for direct unit testing. */
-export function formatContextBudgetReport(budget: ContextBudget): string {
-	const lines: string[] = ["Papyrus passive context budget", ""];
-
-	lines.push(`Rules (active, injected every relevant turn): ${budget.rules.entries.length} rules · ${budget.rules.totalCharacters} chars · ~${budget.rules.totalEstimatedTokens} tokens`);
-	if (budget.rules.entries.length > 0) {
-		lines.push("  Largest:");
-		for (const entry of budget.rules.entries.slice(0, REPORT_MAX_ROWS)) {
-			lines.push(`  ${entry.characters.toString().padStart(5)} chars (~${entry.estimatedTokens} tok)  ${truncate(entry.title, 60)}`);
-		}
-	}
-	lines.push("");
-
-	lines.push(`Skills (Pi-native catalog, injected at startup): ${budget.skills.entries.length} skills · ${budget.skills.totalCharacters} chars · ~${budget.skills.totalEstimatedTokens} tokens`);
-	if (budget.skills.entries.length > 0) {
-		lines.push("  Largest:");
-		for (const entry of budget.skills.entries.slice(0, REPORT_MAX_ROWS)) {
-			lines.push(`  ${entry.characters.toString().padStart(5)} chars (~${entry.estimatedTokens} tok)  ${truncate(entry.name, 40)}`);
-		}
-	}
-	if (budget.skills.scannedDirectories.length > 0) {
-		lines.push(`  Scanned: ${budget.skills.scannedDirectories.join(", ")}`);
-	} else {
-		lines.push("  No skill directories found (checked Pi's documented global/project locations and settings.json's skills array).");
-	}
-	lines.push("");
 
-	lines.push(`Total passive tax: ~${budget.totalEstimatedTokens} tokens across ${budget.rules.entries.length + budget.skills.entries.length} items, before a single user message or tool call.`);
-	return lines.join("\n");
-}

package/extension/src/context-view.ts

@@ -1,17 +1,30 @@
 import type { ExtensionCommandContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
 import { matchesKey, truncateToWidth, type TUI } from "@earendil-works/pi-tui";
-import type { ContextBreakdown, ContextSegment, ContextSegmentItem } from "./context-budget.ts";
-import { formatContextBudgetReport, type ContextBudget } from "./context-budget.ts";
+import type { ContextBreakdown, ContextSegment } from "./context-budget.ts";
 
-const DRILLDOWN_VISIBLE_ROWS = 15;
+const VISIBLE_ROWS = 24;
 
 const SEGMENT_COLORS: Record<ContextSegment["key"], ThemeColor> = {
 	rules: "accent",
 	tasks: "success",
 	skills: "mdLink",
+	basePrompt: "warning",
+	messageHistory: "syntaxFunction",
 	other: "muted",
 };
 
+/**
+ * One row in the unified scrollable view. Every segment that has any real (nonzero) content
+ * is fully expanded inline -- there is no separate "select a segment, then drill in" step.
+ * `key` drives this row's color; `isHeader` distinguishes a segment's own summary line from
+ * its item rows underneath it.
+ */
+export interface ContextRow {
+	key: ContextSegment["key"];
+	isHeader: boolean;
+	text: string;
+}
+
 function formatTokenCount(tokens: number): string {
 	return tokens >= 1000 ? `${(tokens / 1000).toFixed(1)}k` : String(tokens);
 }
@@ -21,35 +34,47 @@ function percentOf(part: number, whole: number): string {
 }
 
 /**
- * Renders the context window as one proportional stacked bar, one colored run of block
- * characters per segment, matching each row's own swatch color below it. A zero-token
- * breakdown (nothing observed yet) renders an empty dim track rather than a divide-by-zero.
+ * Flattens every segment with real content into one linear row list, filtering out anything
+ * that is genuinely zero rather than displaying a misleading "0 tok  0.0%" row -- a segment or
+ * item with literally nothing in it carries no information and is pure noise in a scrollable
+ * view meant to show where tokens actually go. A segment whose OWN total is zero but whose
+ * items are also all zero is dropped entirely; a segment with a nonzero total is always kept
+ * even if all its items individually round to zero (the total itself is real signal).
  */
-export function renderContextBar(theme: Theme, segments: ReadonlyArray<ContextSegment>, width: number): string {
-	const total = segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
-	if (total <= 0 || width <= 0) return theme.fg("dim", "░".repeat(Math.max(0, width)));
-	let used = 0;
-	let output = "";
-	segments.forEach((segment, index) => {
-		const isLast = index === segments.length - 1;
-		const cells = isLast ? width - used : Math.round((segment.estimatedTokens / total) * width);
-		used += cells;
-		if (cells > 0) output += theme.fg(SEGMENT_COLORS[segment.key], "█".repeat(cells));
-	});
-	return output;
+export function buildContextRows(breakdown: ContextBreakdown): ContextRow[] {
+	const rows: ContextRow[] = [];
+	const denominator = breakdown.totalTokens ?? breakdown.segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
+	for (const segment of breakdown.segments) {
+		const items = (segment.items ?? []).filter((item) => item.estimatedTokens > 0).sort((a, b) => b.estimatedTokens - a.estimatedTokens);
+		// A genuinely-unknown segment (basePrompt before the first observed turn) must stay
+		// visible even when its placeholder value is zero -- hiding it would misrepresent
+		// "not measured yet" as "measured and empty", the same honesty problem overshootTokens
+		// exists to prevent for the unaccounted bucket.
+		if (segment.estimatedTokens <= 0 && items.length === 0 && !segment.unknown) continue;
+		rows.push({
+			key: segment.key,
+			isHeader: true,
+			text: `${segment.label} — ${segment.estimatedTokens} tok (${percentOf(segment.estimatedTokens, denominator)})`,
+		});
+		for (const item of items) {
+			rows.push({ key: segment.key, isHeader: false, text: `  ${item.estimatedTokens.toString().padStart(6)} tok  ${item.label}` });
+		}
+	}
+	return rows;
 }
 
 class ContextViewport {
-	private selectedIndex = 0;
-	private drillDown: ContextSegment | null = null;
-	private drillIndex = 0;
+	private offsetY = 0;
+	private readonly rows: ContextRow[];
 
 	constructor(
 		private readonly tui: TUI,
 		private readonly theme: Theme,
 		private readonly breakdown: ContextBreakdown,
 		private readonly close: () => void,
-	) {}
+	) {
+		this.rows = buildContextRows(breakdown);
+	}
 
 	invalidate(): void {}
 
@@ -69,103 +94,81 @@ class ContextViewport {
 		} else if (this.breakdown.totalTokens !== null) {
 			lines.push(truncateToWidth(`${formatTokenCount(this.breakdown.totalTokens)} tokens (model context window unknown)`, contentWidth, ""));
 		} else {
-			lines.push(theme.fg("dim", "No real usage reported yet — segment sizes below are Papyrus's own estimates only"));
+			lines.push(theme.fg("dim", "No real usage reported yet — sizes below are Papyrus's own estimates only"));
 		}
 		lines.push(renderContextBar(theme, this.breakdown.segments, contentWidth));
-		lines.push("");
-
-		if (this.drillDown) {
-			lines.push(...this.renderDrillDown(contentWidth));
-		} else {
-			lines.push(...this.renderSegments(contentWidth));
+		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(border);
-		return lines;
-	}
+		lines.push("");
 
-	private renderSegments(width: number): string[] {
-		const theme = this.theme;
-		const lines: string[] = [];
-		const denominator = this.breakdown.totalTokens ?? this.breakdown.segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
-		this.breakdown.segments.forEach((segment, index) => {
-			const selected = index === this.selectedIndex;
-			const cursor = selected ? theme.fg("accent", "❯") : " ";
-			const swatch = theme.fg(SEGMENT_COLORS[segment.key], "██");
-			const title = selected ? theme.bold(segment.label) : segment.label;
-			const percent = percentOf(segment.estimatedTokens, denominator);
-			const drillHint = segment.items && segment.items.length > 0 ? theme.fg("dim", ` (${segment.items.length} items — enter to expand)`) : "";
-			lines.push(truncateToWidth(`${cursor} ${swatch} ${segment.estimatedTokens.toString().padStart(6)} tok  ${percent.padStart(5)}  ${title}${drillHint}`, width, ""));
+		this.visibleWindow().forEach(({ row, index }) => {
+			const gutter = theme.fg(SEGMENT_COLORS[row.key], "▌");
+			const text = row.isHeader ? theme.bold(row.text) : row.text;
+			lines.push(truncateToWidth(`${gutter} ${text}`, contentWidth, ""));
+			void index;
 		});
+		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", "↑↓ select · enter expand · esc close"));
+		lines.push(theme.fg("dim", "↑↓ scroll · esc close"));
+		lines.push(border);
 		return lines;
 	}
 
-	private renderDrillDown(width: number): string[] {
-		const theme = this.theme;
-		const segment = this.drillDown!;
-		const items: ContextSegmentItem[] = segment.items ?? [];
-		const lines: string[] = [truncateToWidth(theme.fg("muted", `${segment.label} — largest first`), width, "")];
-		if (items.length === 0) {
-			lines.push(theme.fg("dim", "  (nothing to break down further)"));
-		} else {
-			const start = Math.max(0, Math.min(this.drillIndex - Math.floor(DRILLDOWN_VISIBLE_ROWS / 2), items.length - DRILLDOWN_VISIBLE_ROWS));
-			const end = Math.min(start + DRILLDOWN_VISIBLE_ROWS, items.length);
-			for (let index = start; index < end; index++) {
-				const item = items[index]!;
-				const selected = index === this.drillIndex;
-				const cursor = selected ? theme.fg("accent", "❯") : " ";
-				const title = selected ? theme.bold(item.label) : item.label;
-				lines.push(truncateToWidth(`${cursor} ${item.estimatedTokens.toString().padStart(6)} tok  ${title}`, width, ""));
-			}
-			lines.push(theme.fg("muted", `  ${this.drillIndex + 1}/${items.length}`));
-		}
-		lines.push("");
-		lines.push(theme.fg("dim", "↑↓ scroll · esc back"));
-		return lines;
+	private visibleWindow(): Array<{ row: ContextRow; index: number }> {
+		const end = Math.min(this.offsetY + VISIBLE_ROWS, this.rows.length);
+		const result: Array<{ row: ContextRow; index: number }> = [];
+		for (let index = this.offsetY; index < end; index++) result.push({ row: this.rows[index]!, index });
+		return result;
 	}
 
 	handleInput(data: string): void {
-		if (this.drillDown) {
-			const items = this.drillDown.items ?? [];
-			if (matchesKey(data, "escape")) this.drillDown = null;
-			else if (matchesKey(data, "up")) this.drillIndex = Math.max(0, this.drillIndex - 1);
-			else if (matchesKey(data, "down")) this.drillIndex = Math.min(Math.max(0, items.length - 1), this.drillIndex + 1);
-			else return;
-		} else {
-			if (matchesKey(data, "escape")) { this.close(); return; }
-			if (matchesKey(data, "up")) this.selectedIndex = Math.max(0, this.selectedIndex - 1);
-			else if (matchesKey(data, "down")) this.selectedIndex = Math.min(this.breakdown.segments.length - 1, this.selectedIndex + 1);
-			else if (matchesKey(data, "enter")) {
-				const segment = this.breakdown.segments[this.selectedIndex];
-				if (segment?.items && segment.items.length > 0) {
-					this.drillDown = segment;
-					this.drillIndex = 0;
-				}
-			} else return;
-		}
+		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();
 	}
 }
 
-/** Non-interactive fallback (print mode, RPC, etc.) reuses the existing plain-text report shape. */
-function fallbackReport(breakdown: ContextBreakdown, ruleBudget: ContextBudget["rules"]): string {
-	const skillsSegment = breakdown.segments.find((segment) => segment.key === "skills");
-	const other = breakdown.segments.find((segment) => segment.key === "other")!;
+/**
+ * Renders the context window as one proportional stacked bar, one colored run of block
+ * characters per segment, matching each row's own gutter color above/below it. A zero-token
+ * breakdown (nothing observed yet) renders an empty dim track rather than a divide-by-zero.
+ * Zero-token segments contribute no cells and are effectively invisible in the bar, matching
+ * their exclusion from the row list below it.
+ */
+export function renderContextBar(theme: Theme, segments: ReadonlyArray<ContextSegment>, width: number): string {
+	const total = segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
+	if (total <= 0 || width <= 0) return theme.fg("dim", "░".repeat(Math.max(0, width)));
+	const nonZero = segments.filter((segment) => segment.estimatedTokens > 0);
+	let used = 0;
+	let output = "";
+	nonZero.forEach((segment, index) => {
+		const isLast = index === nonZero.length - 1;
+		const cells = isLast ? width - used : Math.round((segment.estimatedTokens / total) * width);
+		used += cells;
+		if (cells > 0) output += theme.fg(SEGMENT_COLORS[segment.key], "█".repeat(cells));
+	});
+	return output;
+}
+
+/** Non-interactive fallback (print mode, RPC, etc.): the same unified row list, as plain text lines. */
+function fallbackReport(breakdown: ContextBreakdown): string {
 	const totalLine = breakdown.totalTokens !== null
 		? `Real usage: ${breakdown.totalTokens} tokens${breakdown.effectiveBudget !== null ? ` / ${breakdown.effectiveBudget} usable budget (${percentOf(breakdown.totalTokens, breakdown.effectiveBudget)})` : ""}`
 		: "Real usage: not yet reported";
-	return [
-		totalLine,
-		`Everything else (base prompt, message history, tool defs): ~${other.estimatedTokens} tokens`,
-		"",
-		formatContextBudgetReport({ rules: ruleBudget, skills: { entries: [], totalCharacters: 0, totalEstimatedTokens: skillsSegment?.estimatedTokens ?? 0, scannedDirectories: [] }, totalEstimatedTokens: ruleBudget.totalEstimatedTokens }),
-	].join("\n");
+	const overshootLine = breakdown.overshootTokens > 0 ? [`Estimates exceed real total by ~${breakdown.overshootTokens} tok -- sizes below are approximate, not exact`] : [];
+	const rows = buildContextRows(breakdown);
+	const rowLines = rows.length > 0 ? rows.map((row) => row.text) : ["(nothing observed yet)"];
+	return [totalLine, ...overshootLine, "", ...rowLines].join("\n");
 }
 
-export async function showContextView(ctx: ExtensionCommandContext, breakdown: ContextBreakdown, ruleBudget: ContextBudget["rules"]): Promise<void> {
+export async function showContextView(ctx: ExtensionCommandContext, breakdown: ContextBreakdown): Promise<void> {
 	if (ctx.mode !== "tui") {
-		ctx.ui.notify(fallbackReport(breakdown, ruleBudget), "info");
+		ctx.ui.notify(fallbackReport(breakdown), "info");
 		return;
 	}
 	await ctx.ui.custom<void>((tui, theme, _keybindings, done) => new ContextViewport(tui, theme, breakdown, done));

package/extension/src/index.ts

@@ -27,7 +27,7 @@ import { ActiveTaskContinuation, automaticPauseReason, shouldResumeFocusOnHumanI
 import { buildTaskWidgetProjection, type TaskWidgetProjection } from "./task-widget.ts";
 import { TASK_STATUS_PRESENTATION, taskTreeConnector } from "./task-presentation.ts";
 import { buildContextInjection } from "./context-injection-telemetry.ts";
-import { buildContextBreakdown, computeContextBudget, computeRuleBudget } from "./context-budget.ts";
+import { buildContextBreakdown, computeContextBudget, computeRuleBudget, estimateMessageHistoryTokens, type SessionBranchEntryLike } from "./context-budget.ts";
 import { showContextView } from "./context-view.ts";
 import { emitTaskFocusEvent, setTaskFocusEventBus } from "./task-focus-events.ts";
 import { renderPapyrusToolCall, renderPapyrusToolResult } from "./tool-rendering/index.ts";
@@ -160,6 +160,11 @@ export default async function (pi: ExtensionAPI) {
 	let contextInjectionSequence = 0;
 	const contextInjectionProducerId = randomUUID();
 	let previousContextInjectionFingerprint: string | undefined;
+	// Cached from the most recent before_agent_start observation: Pi's own base system prompt
+	// is only ever visible transiently inside that hook's event.systemPrompt, so /context
+	// reuses the size buildContextInjection already computes every turn rather than going
+	// without it entirely.
+	let lastObservedBasePromptTokens: number | null = null;
 	const taskContinuation = new ActiveTaskContinuation({
 		maxTurns: TASK_DRIVER_MAX_TURNS,
 		maxUnchangedTurns: TASK_DRIVER_MAX_UNCHANGED_TURNS,
@@ -416,21 +421,30 @@ export default async function (pi: ExtensionAPI) {
 		handler: async (_args, ctx) => {
 			try {
 				const sessionId = ctx.sessionManager.getSessionId();
-				const [rules, taskSummary] = await Promise.all([
+				const [rules, openTasks] = await Promise.all([
 					callService<Record<string, unknown>, Array<Pick<Artifact, "id" | "title" | "body" | "extra">>>("rules.injectable", { project_root: ctx.cwd, session_id: sessionId }),
-					callService<Record<string, unknown>, string | null>("tasks.context", { project_root: ctx.cwd, session_id: sessionId }),
+					callService<Record<string, unknown>, Artifact[]>("tasks.list", { project_root: ctx.cwd, session_id: sessionId, limit: 200 }),
 				]);
 				const { skills } = computeContextBudget(rules, ctx.cwd);
 				const ruleBudget = computeRuleBudget(rules);
 				const usage = ctx.getContextUsage?.();
+				const branch = ctx.sessionManager.getBranch() as unknown as SessionBranchEntryLike[];
+				// Sized individually (title+body) so the Tasks segment can be drilled into like Rules
+				// and Skills; this is a per-task approximation, not a byte-identical reproduction of
+				// tasks.context's own current/next/rejected selection and rendering.
+				const taskItems = openTasks
+					.filter((task) => task.status !== "done" && task.status !== "canceled")
+					.map((task) => ({ label: task.title, estimatedTokens: Math.ceil((task.title.length + task.body.length) / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN) }));
 				const breakdown = buildContextBreakdown({
 					totalTokens: usage?.tokens ?? null,
 					contextWindow: ctx.model?.contextWindow ?? null,
 					ruleBudget,
-					taskEstimatedTokens: taskSummary ? Math.ceil(taskSummary.length / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN) : 0,
+					taskItems,
 					skills,
+					basePromptEstimatedTokens: lastObservedBasePromptTokens,
+					messageHistoryEstimatedTokens: estimateMessageHistoryTokens(branch),
 				});
-				await showContextView(ctx, breakdown, ruleBudget);
+				await showContextView(ctx, breakdown);
 			} catch (error) {
 				ctx.ui.notify(`Context breakdown failed: ${error instanceof Error ? error.message : error}`, "error");
 			}
@@ -502,6 +516,7 @@ export default async function (pi: ExtensionAPI) {
 				previousFingerprint: previousContextInjectionFingerprint,
 			});
 			previousContextInjectionFingerprint = injection.observation.fingerprint;
+			lastObservedBasePromptTokens = Math.ceil(injection.observation.before.characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN);
 			pi.events.emit(PAPYRUS_CONTEXT_INJECTION_CHANNEL, injection.observation);
 			if (injection.prompt !== (event.systemPrompt ?? "")) return { systemPrompt: injection.prompt };
 		} catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],